Technical Design Portfolio
Player Data Tracking Tool
A reusable Unity tool for logging player behavior data across multiple projects.
Role: Technical Designer
Course: Technical Design 2
Engine: Unity (C#)
Type of Tool: Internal / Systems Design
Overview
Context
This tool was created as part of a Technical Design course where I was given free rein to design any tool without limitations. I chose to focus on a system that could support user research and rapid prototyping by tracking player behavior.
Adjusting Base/Scaling Difficulty in Enemy Stats
Shortening Code to Efficiently Spawn Different Enemy Types
Design Goal
My primary goal was to make the tool as universal and portable as possible. It needed to be:
Easy to drag-and-drop between projects
Configurable with minimal code changes
Extensible so new variables may be added to track
Challenges & Solutions
Challenge: Checkpoint Order
Because this was one of my first tools in Unity, a lot of the process was experimental. The biggest issue I ran into was how I gathered data via a checkpoint system. If checkpoints were placed out of order in the scene, the resulting data format became mixed and difficult to read.
Solution: Checkpoint Labeling System
To solve this, I:
Implemented a way for users to have checkpoints spawn already labeled
Have the checkpoint data saved using their labels
Placing a “Final Checkpoint” label to check for when the data automatically saves
This change made the tool more robust and safer to hand off to other team members.
Impact & Reflection
Impact in Playtesting
Enabled passive data collection during playtests, on top of other research methods
Made it easy to add or move checkpoints to focus on specific areas of a level
Supported both survey-based and observation-based research by providing hard data in parallel
What I Learned
Gained experience designing reusable systems rather than one-off scripts
Learned how small UX details for designers (like checkpoint labels) significantly improve tool reliability
Identified future improvements, such as adding CSV export or integrating with in-engine analytics dashboards
A Unity tool for rapidly altering different enemy’s base stats and how much they increase in difficulty
Role: Technical Designer
Project: Hunter (Personal Project)
Engine: Unity (C#)
Type of Tool: Internal / Systems Design
Overview
Context
This tool was created as part of my personal solo project where I was designing four different enemy types. I wanted a way to alter what their base stats were along with how much they increase after each phase for quick balance changes.
Design Goal
My primary goal was to make the tool quick and easy to use. It needed to have:
Simple UI with dropdown stats
Influence on other scripts involving enemy stats
Extensible so new stats or enemies may be added
Challenges & Solutions
Challenge: Communicating with all scripts
When originally making my scripts in this project, I had created their stats in a way that was only present in their own enemy logic. So, to create this tool, I needed to influence their stats without having their original stats override their new stats.
Solution: All values in one place
To solve this, I:
Removed all old variables of enemy stats
Left empty variables to be filled
Made the stats come directly from the tool itself, and fill in the empty variables when the enemy spawns
This change made the tool more bug-free and less confusing to read in the script.
Impact & Reflection
Impact in Rapid Prototyping
Allowed for quick changes to increasing difficulty
Made it easy to access all enemy stats of different enemy types
Opened opportunities for data comparisons during playtesting
What I Learned
Gained experience in creating universal values
Learned how a relatively easy to create tool can immensely improve the balancing process
Identified future improvements, such as mid-session alterations and adaptive difficulty based on other enemy presence
An in-depth way to spawn different enemy types with half the amount of code.
Role: Technical Designer
Project: Hunter (Personal Project)
Engine: Unity (C#)
Type of Tool: Internal / Systems Design
Overview
Context
This tool was created as part of my personal solo project where I was designing six different enemy types. When spawning each creature, I had a complicated way of assigning their spawn stats, when they’d spawn, and more. As more enemy types appeared, this method quickly caused problems.
Design Goal
My primary goal was to make the tool as simple as possible. It needed to:
Spawn enemies semi-randomly
Hold all enemies in one uniform class
Allow for each class to be contain their own customizable stats
Challenges & Solutions
Challenge: One class for all
This entire process was experimental, since I have never needed to spawn enemies in such a similar, but different way. Since simplicity was the key here, I explored many different ways I could condense all of my enemies into the most minimal amount of code possible.
Solution: Creature types
To solve this, I:
Created an enum containing the types of each enemy
Checked their type when preparing to spawn them
Made their values customizable in the inspector for any balance changes
This change made the tool more concise and easier to handle.
Impact & Reflection
Impact in Readability
Allowed future additions/changes in this script to be altered with ease
Immensely shortened the code by hundreds of lines
Added ways to alter enemy spawn logic in the inspector, in addition to disabling/enabling enemies during testing
What I Learned
Gained experience in utilizing enums
Explored alternate ways of randomly spawning characters
Identified future improvements, such as adding characteristics to their spawn behavior