As Within is a small-scale deck builder with body horror elements about the way in which people lose themselves while chasing power and perfection. This was made as the capstone project for my university degree alongside four others. I was in charge of the game/level design and balancing as well as being the lead programmer. This project was very valuable as I have improved my skills in these areas, as well as proper planning and communication, greatly. Above is a link to the design document

The game is made up for cards that attack each other in four lanes. Cards have an attack, defense, durability, and a possible ability. Durability is the health of a card, and upon reaching 0, is destroyed. Each turn the durability of a card is reduced by 1 giving them a limited lifetime on the board ensuring the player is required to make use of their whole deck, and not rely on playing a single strong card and winning. This was heavily inspired by the wall mechanic in Cassette Beasts by Bytten Studio. This mechanic creates a wall that prevents damage on a turn countdown which also reduces when hit. This second part of the mechanic was also used as inspiration for when cards attack.

When a card attacks, it lowers its opponents defense by its attack. If the defense drops below 0, its defense breaks and it takes 1 damage to its durability. If a card is attacked with a broken defense, it also loses 1 durability. This instance-based damage approach still encourages high attack cards as they can break through defense, but it ensures that other playstyles are still viable as high damage doesn’t guarantee fast damage.

Whilst this is all good, you may have noticed that there are no costs to playing cards. This is because the player is able to play only one card per turn, which acts as a pseudo-cost. However, whenever a card is removed from the board, be it via damage, passive durability loss, or something else, the owner of that card takes 1 damage. This also acts as a pseudo-cost, making the player consider the cost benefit of the card as it will eventually lead to a loss of health. Playing a weak card might stop damage now but waiting to play a stronger card you draw next turn will turn the tide of the battle and cost the same.

For the deck building aspect, after each battle, the player can choose from 2 different cards to replace another in their deck. Then, after each stage (3 battles), the player can choose from 2 relics that have abilities that effect the whole board like giving all your cards +1 attack or reducing timers twice as fast. Initially, there were no relics and playtests showed that the players sense of power progression was not particularly noticeable as it was a small addition each time. By adding in the relics, the player would now have a large jump in power every stage providing a better sense of the player curve to them.  

Balancing the game was quite tricky, however, since the project used datatables to store data on all the cards, enemies, and levels, it was much easier as I could simply export it as a csv and mess around with everything that way. This let me create tables to measure the averages and counts of stats that the player and enemy would have in each level to keep them at a fun level. The difficulty of this became quite difficult because the abilities of each card effect stats in different ways. Some were easier to work around, such as doubling the recorded attack of the double attack ability even though this didn’t consider the 2 durability damage it could inflict, but harder with many others, suck as spikey defense that inflicts durability damage when attacked. Thankfully, I believe I did a good job at keeping the balance at a level that is difficult, but still fun. The only downside to this approach with datatables is that this was my first time properly using spreadsheets, so I didn’t have a master sheet that was referenced by the others, requiring me to input all the changes I made manually rather than re-importing the csv.

On the programming side of things, I was in charge of planning the project and making the core gameplay systems. I went with a Finite State Machine (FSM) as the game is very heavily inspired by Magic the Gathering and has very discrete phases it transitions through. This made the ordering of logic very easy as it just required simple ordering of when to change between each state. This did lead to some issues though, as I never considered the need for time between actions to allow the player to see what is happening. This required using a timer that cycled through each piece of logic in a state resulting in some unwieldy code. In future I believe a better option would be to still have the FSM as it is, but use a proper timer (like those built into Unreal) as a secondary FSM in each state that then calls the logic between their transitions. This would lead to much more easily expandable, readable, and modifiable code.

I also discovered datatables and how useful they can be when storing data to be loaded into actors (in this instance, cards). This allows easy addition and modification of cards, levels, enemies, and more and as mentioned earlier, was extremely beneficial when balancing the game.