Itch.io: https://matchagatcha.itch.io/executeoperationexecute
Genre : Turn-based Card Game
Development Tools : Unity, PlasticSCM, Asperite, MuseScore
Team Size : Sole Developer
Development Time : ~ 2 months
Execute Operation is a education game meant for users to practice using their mathematical skills via the various operations. Players will use various cards to manipulate numbers in order to wage combat with the enemy.

Game Design Documents
Narrative
Since the content for this game was to make an educational STEM game, I knew I wanted to work with math, as numbers are a driving force behind every game. With math, I thought about the feeling and values associated with it. Logic, systems, and orders rose to the top of my head.
With this in mind, I created the enemy group Irrational Imaginary Integer Interlopers, which are referred as the Quadratic I. Irrational and imaginary numbers are ones that are serve as an antithesis to the aforementioned values, with irrational being unrepresentable and imaginary existing beyond the traditional scope. Integer and interlopers round out the title, and indicate their status and villainy to the world. The four words make up for a nice alliterative name, but I made use of this to create another alias for the group, the Quadratic I, in order to reference the quadratic formula.
Integer interlopers was the working name early in the process, to be I^2, but was expanded upon into the Quadratic I. The inclusion of imaginary and irrational also gave way to a branch of enemies. As future levels would get difficult, both of these concepts would be themed enemies to tackle on in the game. Imaginary number-themed enemies would be sly and cunning, using buffs and stealth to remain elusive and seemingly out of grasp in order to capture that feeling of existing beyond the traditional sense. On the other hand, irrational numbers are never-ending, unable to be captured in a perfect representation without approximation. So I saw them as berserkers and agents of chaos. Enemies that would have everlasting endurance, and are quite unpredictable, in order to capture the essence of on-going possibility.
In the overall world of Mathematica, the Equalizer, or the equals sign is the symbol of unity that holds the world together, A grand pillar of the fundamental logic that math tends to employ. As such, the realm of Mathematica is one that assigns worth to individuals, a numerical system of status that segregates based on four primary types of categorization: addition, subtraction, multiplication and division. This society is closest and stuck in its way. The nefarious Quadratic I, those who exist beyond these rudimentary labels, steals the Equalizer, and removes that veil of stability from the world in order to change these very fundamentals.
As balance is shattered, 4 various heroes, each from the different branches, will individually journey from their home in pursuit of Quadratic I, and along the way, will learn to use the other operations of math together. With a sum greater than its parts, the heroes will traverse the land and learn myriad ways of life of those outside their city hold, learning math operations that apply these concepts on a higher level as they face greater dangers.
Who is Quadratic I, and why did they steal the Equalizer? The heroes will grapple with these questions, and as they venture forward, find their own perspective challenged in what the world of math means to a society. As they solve their way across the lands, and search for the fundamental symbol of operations, they will ask themselves in the end: What does it mean to be equal?
Design Process
Taking inspiration from other number-heavy card games such as Slay The Spire and Balatro, I wanted my game to have that same satisfying feel when you calculate the exact path to victory in any given moment. Slay The Spire definitely had the heaviest influence on the systems, with the targeting and turn-based pattern. However, since the core mechanic was players operating their way to a certain goal number while the enemy does the same, the idea to split the game into turns and rounds, with unique distinctions between the two, came into light. This was so the balance of moves between the two sides was relatively similar, with a slight priority on the player’s round to give them an advantage. Additionally, having turns signify and change the goal number allowed the game to have a more layered combat system, scalable into future mechanics such as damage over time, or turn manipulation that I wanted to work into the game.
After the first couple rounds of testing, I found a way to cheese my own game. You never had to actually get to the number, you just had to be closer when the turn ended, and you would be immune to any sort of damage. All you had to do was play one card to get your number any amount closer than the enemy, you could be on a 3 and the enemy on a 2 with the goal at 100, and if you ended the turn, only the enemy would be damaged despite you both being far. In order to change that, I incorporated chip damage, if you were not at the exact goal number, you would take half the difference as damage. This would still allow some quick plays like before, but becoming too reliant on it eventually meant you would just take too much sustained damage and lose. This also encouraged trying to get close to the number even if your hand was bricked, as you could negate a ton of damage long term in losing situations. To compliment this feature, I also added a heal if you did reach a perfect number, for both the player and the enemy to reward precision on the players end, and discourage stalling too long in fear the enemy will be able to heal as well.
Implementation
During the initial parts of set-up, I took some time to write out what systems I wanted to have, how to implement it, what needs to derive from each one, and what would be “core” to the experience to make it feel fleshed out. The comprehensive break-down of my top 3 to-dos was as follows:
Core Systems/Mechanics: (Highest Priority)
- Turn-Based Game
- Switch between enemy and player
- Ending rounds
- Restart and new fight
- Card Objects
- Dragging/dropping
- Card draw/hand management
- Assigning values
- Assigning operation effects
- Characters
- Health / damage taking
- Actions per turn
- Difficulty for enemies
Out of all of the 3, I decided to create cards first which took quite a bit of trial and error to figure out.
After creating a base class for Card to hold all the relevant variables and functions, the main issue I was running into was having the cards be tangible objects for players to move and “play” with their mouse by clicking and dragging and releasing.
In this chunk of implementation, I worked with splines to create a curved line for the classic look of a “hand of cards” so often seen.
Then I created some squares to serve as play areas for the cards, one for targeting enemies, one for simply playing as is. Players had to drag and drop cards from the hand over to the squares in order to activate them.
At the time, both were squares with a placeholder color, and were set to have no visuals. As development continued, I focused more on the player play area, shown in the top image. which has a border that pop-ups when hovering a card.
The enemy play area, is not in the game, and is set to be invisible in the actual build. These squares had scripts attached that detected any objects with Card components overlapping with it and if it was released directly over it, it would call it’s play effect.
Then I added functions to the card class that tracked the GameObjects main position relative to the camera so that we could update the transform with the mouse dragging. Additionally the initial click stores the position of the original spot in case it doesn’t get dropped in the play areas. This, combined with the play areas, allowed me to provide full functionality of moving cards.
However, numerical functionality of the cards was not yet present, and at this stage I could only fill my hand at the start of the game, drag and drop cards in the play areas to destroy them, and refill my hand by pressing a draw card button.


With my cards being tangible, I switched workflow for a little and started to create some assets for the cards. Since this was a solo project with a small scale and relatively lax time constraint (around 2 months), I wanted to use 2-D pixel art to avoid the lengthy process of 3-D asset creating. Thus I used Asperite to make some basic cards based on each of the basic math operations; addition, subtraction, multiplication and division.




With the four elements complete, it was time to create some characters and numbers for the cards to work with. Note that these cards have no text on them, as I wanted the text to be dynamic for easy alterations in the future, though this system would turn out to be a little bit of a pain to make down the road.
The next chunk of implementation had me focused on the combat system, which includes the turn manager, the combatants and their relevant numbers, and attaching victory and defeat conditions. In order to avoid systems being too tightly coupled together, I decided to go with a function that utilizes UnityEvents and an enum of a custom GameState variable to keep track of which phase the combat is in. With that, I could invoke events that are subscribed through one singular function in the TurnManager class and make sure things were only triggering in their expected phase.
With the core mechanics complete within the first month of development, the next cycles in the following month up to the deadline mostly revolved around polish; adding UI, SFX, creating more visual clarity, and adding an enemy AI to play against. The following features were added:
Enemy AI:
The enemy AI would activate during the EnemyTurn gamestate, and had the following simple behaviors.
- Add or Multiply when below the target
- Subtract or Divide when above
- End combat round upon reaching target number
- Upon defeat of one foe, player can continue with numbers being scaled up for the next enemy
Visuals:
- UI/UX implemented
- Main menu functionality
- Player controls (end turn button, play area hover visual)
- Fonts customized for each card
- Combat
- Player/Enemy
- Sprites
- HP Bars
- Combat Log in center
- Player/Enemy
- Background and borders establishdd
Sound:
- SFX:
- Taking damage
- Healing
- Playing cards
- Music:
- Main menu music
- Combat music
Throughout the entire process, I mostly kept to my own creations, and I wanted to avoid even using the Unity asset store for the core components. But in I did use some outside elements to help complete this game. One most notable is the art assets of the characters and main menu. The designs of them are not my own, and are pixelated versions of designs from mino_dev’s game, Rabbit and Steel, which I highly recommend anyone to play. The music however, is entirely composed of my own, using MuseScore 4 as my workstation for those pieces.
Scrapped Ideas
Overall, I was extremely satisfied with the game, as I felt it was a great starting point and solid foundation for the upgrades I have envisioned for it in the future. During the development process I continuously talked with my teacher as well as some close friends to have them play-test it and offer their thoughts. While there were some struggles with explaining the premise of it initially, as I fixed the tutorial and added some clarity to it, it seemed easy for most to pick up and have some fun with it. Of course, since the time-line of the project was only around 2.5 months, there were many ideas that were not implemented that were proposed in the draft.
For future development of this project, I aim to implement some of the following:
Advanced Math Operations:
Currently the game only uses 4 simple operations, making it accessible for anyone, even kids. In higher difficulties, I wish to incorporate more complex behaviors, such as exponents and absolute values. However, currently the game represents only whole numerical values, and I wish to expand into trigonometry and involve derivatives and logs and more. I would have to look more into somehow including that in an interactive way that wouldn’t make inclusion awkward.
Card Battle Upgrade:
Currently the player and enemy can only affect themselves, but eventually I want to add cards that have effects on the other players, including buffs and debuffs, to make combat more dynamic.
The enemy AI currently boils down to if this do that behavior, I want to upgrade it so that enemies have a move pool of cards to do more things with the various upgrades. Some encounters would have a group of enemies, while some may be the classic 1v1.
Rogue-like Progression:
Of course, since this game is based off of Slay the Spire, I also dreamed of the same progression, continuing through floors to reach bosses, upgrading your deck with relics and new cards, then dying and trying again.
This would require new systems, and I would need to re-vamp the current card system to fit into a deck that has data managed and saved by the system.
Classes:
While there is only one main protagonist present in this build, there was going to be 4 selectable characters based on the 4 operations, with each one having unique abilities that would embolden their respective operations

