Project Portfolio

While Digipen’s classes exposed me to much of the academic subject matter that is needed to create a good game, my favorite part of the DigiPen Experience has been putting those concepts into practice on gaming projects. There is nothing better than the chance to sharpen my coding skills and wrestle with the game design principals needed to achieve my own vision while collaborating with other (soon to be) game professionals. Some of my games were better than others, but each one provided unbelievable learning that I’ll take with me always.

I organized this page by putting my most recent games first and then moving ‘backwards in time’ to ultimately reach the games that I worked on at the very beginning of my DigiPen experience. 

DigiPen emphasized learning ‘engine fundamentals’ before using more advanced tools.  This means earlier efforts are less polished and visually appealing, because the focus was on using C (Pumpkin Paladin) and then C++ (Gold Swarm) to build lower level capabilities.  BEAR feels a bit more complete, because we were able to build it using the advanced toolsets available in Unreal Engine. Basil and the Isles of Spice was made in Unity and included contributions from artists and sound specialists.

Basil and the Isles of Spice (2023)

Lead Gameplay Developer

Basil and the Isles of Spice is a 3D platformer where you play as a water-running lizard on a quest to become the next shaman!  

My last team (BEAR) asked me to continue leading them, but I got an offer from a former team lead to work on his current project. Basil presented a chance to work on a larger team that included artists and sound specialists- all in a new engine for me.  This was just too good to pass up! 

I was initially added to the team to improve a character controller that programmers and designers considered limiting. Prior to my involvement, character control was one of the most criticized features during playtests.  The team was so pleased with the improved playability that came from the design decisions I made while refactoring the code, they asked me to expand my role into more design-centric areas.

I ultimately ended up getting my hands dirty with virtually every part of the project - designing levels, cutscenes, and NPC interactions (among other things) while also working as the Lead Gameplay Programmer.

The task to refactor the character controller gave me a chance to re-architect a code stack that was technically limiting.  This provided me an opportunity to work with a state machine for the first time while experimenting with several more subtle design concepts that are known to improve the feel of movement for players – turning character control into one of the games most frequently cited strengths.  Concepts that were most impactful included:

  • Coyote Time 

  • Input Buffering 

  • Adaptive Braking Acceleration 

  • Variable Jump Height 

  • Hangtime 

  • Adaptive Gravity 

Designing the ‘special moves’ for Basil’s character controller was the key to differentiating her from all the other 3D platformer protagonists out there. For me, life doesn’t get much better than having free license to rapidly prototype ideas without creative constraints. some of my favorite new ‘special moves’ included: 

  • Water Run: my improved character controller code made it possible to offer a completely new way of basic travel by tweaking a few basic values - switching up the gameplay style to provide new context when exploring certain environments. 

  • Water Spin: combine lerping and steering behavior to give the player a satisfying boost of momentum. 

  • Spin Jump: convert the 2nd jump acceleration curve from concave to convex – making the player feel like they’ve caught an air current, but providing all the utility of a standard double jump. 

  • Glide: utilize different base values and lerping to a clamped fall speed to make the player feel like Mary Poppins. 

  • Glide Spin: lerp on all 3 axes toward the input direction for a satisfying burst of mid-air speed. 

  • Wind Tunnels: felt more intuitive and satisfying when I added a minimum exit velocity, ramping acceleration, and max vertical speed to an otherwise linear experience. 

  • Cutscenes: felt more immersive when I collaborated with our sound engineer and cleaned up basic functionality.

Like any game, Basil had dozens of game mechanics that needed to be tweaked, reworked, or implemented entirely from scratch. I ended up designing and programming many of them.  Some of the more notable contributions include:

  • NPC's: brings the characters to life as they rotate to face the player during dialogue.  

  • Camera Auto-Follow: makes navigation easier for kids by slowly rotating the camera towards their movement direction if they haven't touched the camera controls in a few seconds.

While I loved playing previous versions of Basil, I also knew there was a lot of room for improvement in its level design and pushed for a rework. The team shared my opinion, but the decision created a tremendous amount of additional work in what was already an extremely ambitious timeline. Given my active role in the discussion, I felt like it was my responsibility to make the process go smoothly. I ultimately played a major role in delivering our levels and learned that I like Level Design as much as Character Control! 

  • Concept Presentation & Alignment 

  • Sketching Level Layout 

  • Whiteboxing 

  • Set Dressing (Adding Art Assets) 

  • Playtesting, Feedback & Iteration 

BEAR (2022-2023)

Producer / Lead Designer

The entire Gold Swarm team disbanded, so I found myself looking for a new team at the start of the year.  Virtually all work I had done to date was coding centric and focused on building engine-related capabilities, so I was looking for an opportunity to spend more time on design-related work.

I was thrilled when I found a team of almost exclusively RTIS (Real Time Info Systems) students who wanted to focus on coding but were looking for someone to do some heavy lifting on the design side.  We were the perfect match!

While I started on more design-centric tasks, the team needed some help on the coding side, so I pitched in there as well. Ultimately, they asked me to be their producer, which (on our team) meant putting together the entire strategy for completion, organizing all of the workflows, delegating tasks, and managing the deliverable through the end.

We had a great time as a team and received very positive feedback from our professors, who were impressed by how much we accomplished given our small size.  I was flattered when they asked me to lead again, but felt like I needed experience working on a larger team (with artists and sound specialists); so I ended up switching teams after BEAR’s release.

As the only new member of Team Hat Trick, I assumed that the other members were looking for me to confine my contributions to driving the design process. Over time, it became clear that they were looking for me to play a much broader role. Specifically, they wanted a team leader who could deliver a coherent game design and then take accountability for the project as a whole.  I was thrilled to explore this much more strategic role, which gave me the opportunity to:

  • Deliver the concept, design, and implementation strategy for the entire game. 

  • Break the pieces of the game into individual coding tasks. 

  • Manage the team through task creation, tracking, and assignment in JIRA. 

  • Reallocate resources to areas that needed additional help. 

  • Run playtests, identify needed revisions, and adjust schedule to facilitate iteration on results. 

  • Lead milestone check-ins and author all documents for review by professors. 

The team was extremely excited by the game concept I suggested and even more supportive when I began generating ideas for mechanics that we would deliver as part of the game. This provided a clear vision for what the game was going to look like very early – providing a clear focus which helped us stay ahead of schedule. A few of my favorite mechanics include:

  • Ragdolling: was BEAR’s main ability and enhanced game play as well as his unique identity. 

  • Checkpoints: acted as narrative breaks and tension release points while staying within the game's theme. 

  • Ledge Hang: created variety and interest as the player progressed through the level, also providing a ‘last second’ save paradigm which turned potential frustration into thrill and excitement. 

  • Enemies: designed to act as points of high tension and provide self-fulfilling design bridges to previous mechanics to expand on their capabilities. 

  • Crate Pushing: introduced puzzle-like elements to gradually increase tension and add interest to each level. 

  • Conveyor Belts, Sliding, The Gallery, Final Narrative Cards… so much fun design!

Given the style of gameplay, we knew that the look and feel of the levels would be especially important to the game’s success.  This was my first time designing multiple levels for a single project, and each one went through several iterations before the design was finalized, giving me the chance to:

  • Whitebox: blocking out every section of the level as quickly as possible so we get to playtesting and iterating faster.

  • Internal Playtests:  I iterated with the team many times with the goal of aligning vision before moving on to external playtests.

  • Sketch: levels on paper, making sure each has a clear Setup, Hook, Development, Turn, and Resolution that coincide with mechanics and the narrative. 

  • Test: on new players to get feedback on the level and mechanics

  • Iterate: based on both feedback and observations captured during testing

  • Repeat: until complete! This includes optimization, reworks of unclear sections, changes based on mechanic updates, and more. 

This was the first time I had the opportunity to build a player controller for a 3D game. I was under significant time pressure because many important tasks for other team members were gated until it was complete.  The project gave me an excuse to:

  • Use Unreal Engine 5’s Blueprint System to implement player movement. 

  • Utilized a Spring arm component for the camera, with mouse control and adjustable sensitivity. 

  • Used Blender to create the bear’s model and optimize it. 

  • Added Ledge forgiveness for the first time. 

  • Made Animation trees to implement all basic animations, with adjustments to fit the game’s style. 

Gold Swarm (2021-2022)

Programmer

DigiPen’s objective for this 2nd year gaming project was to build an understanding of how games work from the bottom up by building our own engine. Since the entire project was about building these lower level capabilities, it gave me the chance to learn C++, implement base engine features, and connect them with other programmers.  While other members of the team contributed a design, I was 100% focused on developing my coding skills during this project. It is the only project in my portfolio where I did not have any design input. 

My focus on this project was to learn as much about lower-level programming as I could through the creation of a custom engine. The engine utilized C++ and OpenGL for rendering graphics. As a programmer, it was my job to: 

  • Create and implement the base physics system to handle movement for all objects. 

  • Use JSON files to manage serialization & designer integration. 

  • Implement a collision algorithm which calculated and then tracked the results for every object. 

  • Utilize manual memory allocation for dynamic lists and objects. 

As the engine was in its infancy, I was responsible for creating and maintaining the physics system that managed the behavior of all objects in the game. Later, I worked with our graphics programmer to link this system with his rendering system to get objects moving on screen. To accomplish this, I: 

  • Implemented and maintained the system used to move all objects within the game world. 

  • Set up objects in a way to store coordinates and prepare for outside input. 

  • Linked with the rendering pipeline, input system, and base GameObjects to get things moving on-screen. 

  • Made the system serializable for use with JSON files, allowing for designer input. 

Later in the project, my task was to implement the collision algorithm SAT (Separating Axis Theorem). This included the calculations, collision handling, and any physics interaction. Work included: 

  • Adding a rudimentary bounds check using AABB (Axis-Aligned Bounding Box) for performance and speed optimization. 

  • (Note: implementing both algorithms gave us the speed of AABB + the precision and features of SAT when these were needed.)

  • Implementing the Separating Axis Theorem, which offered optimization and the ability to rotate objects. 

  • Developing a velocity system to manage knockback and improve the quality of movement for all objects in the game.

Another one of my contributions was to create a UI system that was flexible enough to be used throughout the game. The system supported all of the menu types we needed - handling the main menu, pausing, and the end-of-game screen which tallied the player’s points. This deliverable included:

  • Creating the system to house buttons, picture elements, and their arrangements which could be used for any menu in the game. 

  • Storing the menus in serializable vectors to easily make changes later. 

  • Implementing unique behaviors for each menu, such as pausing or dynamically adjusting element size. 

Pumpkin Paladin (2021)

Programmer

This was my first real team at Digipen. Our objective was to apply the C programming skills we were learning in class to deliver low level engine contributions that could ultimately be incorporated into a gaming engine. Though I still enjoy working in higher-level systems more, applying C in a game construct and learning how the lower-level objects work together provided valuable context and awareness that I think about when building games in more mature gaming environments.

This game was created in a low-level proprietary DigiPen engine called Alpha Engine, which utilized C as a foundation. All of the systems needed to be designed from scratch, making it necessary to: 

  • Dynamically allocate memory using mem_alloc, with custom calculations to prevent memory leaks. 

  • Design and connect complex, memory-heavy systems. 

  • Create essential systems such as attaching sprites to meshes and then packaging them into game objects. 

My favorite contribution to this project was implementing a new ranged weapons system that could be used for both the player and enemies in the game. This system, as a new addition, had to interface cleanly with the existing ones. To accomplish this, I: 

  • Changed the system later to allow for picking up weapons, a feature added further into development. 

  • Kept code and data objects manageable so other programmers could easily interface with them. 

  • Made a weapons system with stats that could update dynamically. 

To show most of the text needed throughout the game, I implemented a sprite sheet system that could read a file and split it into different sprites. This made it easier to reference the information when needed, load it into the mesh rendering system, and animate all of the objects in our game. Doing this included: 

  • Creating my own custom font for use with the system. 

  • Use this system to program easily editable credits. 

  • Reading data from files to properly split up the sprite sheets 

  • Using char data to translate ASCII input to the sprite sheets. 

Without dedicated designers, we all pitched in to help design the mechanics for this game. Some were pulled from the team’s previous project, and several were designed from the ground up. This entailed: 

  • Designing ranged weapons system to feel intuitive and easy to use. 

  • Changing the core gameplay loop to include a more satisfying progression. 

  • Adding power-ups to give more dynamism to the gameplay. 

  • Scoping all pitched ideas to fit within our expected time frame.