Rapid Prototypes
3 game prototypes built every 4-6 weeks each with a new team.
Bubba Yuga
A co-op puzzle-lite adventure inspired by the Baga Yaga myths. Players are bound by a magical chain and rescue kids lost in a mysterious forest.
Out for Delivery
A mobile-first arcade racing game, players dodge oncoming trucks & go as fast as they dare to earn high scores.
Forgetful Roots
A VR game-lite experience putting players in the shoes of someone with increasingly severe Alzheimer's disease.
Project Constraints
15 team members over 6 weeks, total of 3 designers.
Use Unreal Engine 5, using Perforce for version control.
Use the Baba Yaga folk myths as our starting ‘IP‘.
Design core gameplay around the verb: synchronize.
Bubba Yuga
Key Contributions
Created core design documentation in Miro
Created a gym whitebox that contained example interactions / puzzles.
Blocked out the opening section of the game laying out challenges & level flow.
Created blueprints for the following:
Tracking the kids players rescue in order to beat the game.
The magical house, an NPC which follows players and collects kids.
Doors & Buttons (2 types each).
Cutscenes & Respawning level objs. if they were lost.
About the game
A 2-player co-op puzzle-lite game based on the Slavic folktales of the Baba Yaga. Playing as a pair of tied together witches, you and a friend must work together with your walking house to rescue all the woodland children and break your curse.
Players solve puzzles and challenges in order to reach the lost children and collect them in the house.
Level Design Breakdown - Gym / Puzzle Ramp
For our projects gym (testing ground for mechanics) I was inspired by the puzzle ramp format used by the Rise of the Tomb Raider team.
The basic idea is to create series of puzzles each based on a mechanic. Each puzzle is aimed at generally being ‘harder’ to solve than the last.
While I wasn’t able to fully build a true puzzle ramp for our game (I had very little time before we needed level blockouts) it was a great format for our gym / early playtesting.
Our gym had 3 ramps - buttons (& rocks), the magical house, and the chain.
Level Design Breakdown - Opening Section
With the basics settled on I created a blockout for the opening section of the game.
My design process followed these steps:
Collaborate with fellow designers to establish the core beats for the section.
These beats were effectively the tutorial for the game so they were focused on establishing the core mechanics:
The types of buttons
Using the chain to move objects
Picking up and throwing small objects
Lifting & throwing other players
Via cutscene - Meeting the house and seeing how collecting kids opens the main gates.
Instead of a paper map I moved right into blockout due to time. Focusing on keeping things simple, covering the beats, & leaving lots of room for environment artists to improvise.
I created a winding path with lots of elevation change to keep things interesting for players.
Design Challenge - Cutting for time
Because our core chain mechanic was technically complex we had a limited amount of time to add the additional mechanics we wanted. We ended up cutting multiple mechanics. Here’s how we decided on them.
Picking up twin kids - Players could simultaneously lift a set of twins. This was an option to give a bit more variation on the core goal of collecting kids.
Mortar and Pestle transport - players could hop into a large motor and pestle and travel along a single path by mashing a button / rotating a stick.
Why we cut them:
These mechanics were still not fully functioning towards the end of the project and were taking up valuable resources.
They were synchronous but didn’t serve a strong purpose:
Due to level design changes the Mortar and Pestle no longer served its original purpose as a transition between sections of the levels.
The twin kid pickup was effectively the same mechanic as the single kid which was already fully functioning.
Design Challenge - Building off a verb
The first goal as designers was to establish gameplay direction and core mechanics for us to prototype and test. From there we could experiment, ‘find the fun’, and build. Our foundation set by the team was the following:
An isometric style co-op game with 2 players bound by a chain
Once we decided on a puzzle focus the challenge became:
Create a collection of player abilities & level interactables that work within our verb.
Mix those mechanics together to create interesting puzzles.
Here are some of the mechanics we designed to tackle this challenge. These all involve players working together synchronously to achieve their goals.
Player Abilities
Simultaneously lift large objects.
Wrap the chain around large objects to pull them around the level.
Pick up and throw one another to cross gaps or reach higher areas.
They can ‘pull’ on the chain to drag the other player towards them. This allows them to dangle one player off an edge and pull them backup.
Level Interactables
Buttons that needed to be held down by one player (or rock) to trigger.
Doors that opened once then stayed open as well as doors that needed continuous input to stay open.
Rocks of different sizes that could be picked up, dragged by the chain, or both.
Forgetful Roots
Project Constraints
7 team members over 4 weeks, sole designer.
Built in Unreal Engine 5, using Perforce for version control.
Use Meta Quest 3 VR as the main platform.
Create a serious game (educational, impactful, tied to the real world etc)
Use a neo-impressionist art style (randomly assigned)
Key Contributions
Designed basic mechanics and gameplay flow.
Established design pillars - relatability and emphasized representation.
Relatability - players will get the most out of the game if they can feel and understand the experience of Alzheimer’s.
Emphasized representation - respect the real-world struggles of Alzheimer’s while leaving room for more emphasized symptoms that communicate well during gameplay.
Blocked out the main level using real world apartment metrics
Created Blueprints for the main NPCs, and a typewriter style dialogue system.
Created a short ending cutscene in sequencer.
Wrote the dialogue & player character journal entries.
‘Typewriter’ Dialogue Blueprint Breakdown
(Use right click & CTRL + scroll to navigate)
You can see an example of this system at 5:15 in the video above.
Below are the features of a text dialogue system I created.
Contained in an actor component for reuse anywhere needed.
The system takes in an array of dialogue lines and dialogue settings from the NPC actor when dialogue is called.
The typewriter effect is achieved by building a displayed string. Each letter is added one at a time after a short delay.
You can choose to play an array in full or only certain sections
StartDialogue - sets up the needed variables & components
NextLine - grabs the next line to be played, checks if we’ve reached the final line.
StartTyping - types the next letter, and checks if the line is complete.
Thought Process
I created the system without knowing how much dialogue we would have or exactly how we would be storing it (beyond an array) so I tried to create a flexible & easy system for my team to use.
Overall, I’m happy with how the feature turned out and it was a good experience on building technical features for others to use. I think it could be improved in a number of ways either with more options, smoother camera tracking, and better line spacing / line breaks for the text renderer.
About the game
Forgetful roots is a game-lite VR experience that puts players in the shoes of someone with Alzheimer's over the course of 9 years. Players experience 3 days during which they complete household tasks while dealing with increasing severe symptoms.
We collaborated with an expert at the University of Utah’s Cognitive Disorders Clinic to gain more insight and knowledge about how Alzheimer’s affects people.
Out for Delivery
Project Constraints
8 team members over 4 weeks, total of 2 designers.
Built in Unity, using Git / Github for version control.
Build off an early arcade game ours was Speed Race (1974)
Design for a classic arcade experience & use mobile-only features (gyro, touch screen etc.)
Key Contributions
Created core enemy design documentation in Miro covering:
Basic enemy design (spawning rules, formations, movement behavior)
Special boss trucks (‘attack’ behavior, spawning rules, etc)
Added C# scripts for scoring milestones which extend the game’s timer:
Players get bonus time added to the timer for each score milestone they hit. The amount score needed to reach the next milestone increases each time.
After the 3rd milestone, the amount of score needed increases by the same amount each time and players can continue to reach new milestones as long as they survive.
About the game
Play as a delivery truck driver who takes on the big delivery corporations. Players earn high scores by driving fast, jumping over oil slicks, & dodging oncoming trucks.
They get more time added to the timer as their score increases, if the timer runs out they lose.