Led production workflow from start-to finish

Directed Art & Setup Meetings

Created Data-Driven & polymorphic systems, especially with ScriptableObjects

Implemented JSON saved level progression

Implemented all Art: 3D Models, UI, Textures

Led & Directed Team

Created Experience & Level Progression System

Created Character Customization tied to level progression

Designed and Implemented custom GOAP AI Solution for responsive NPC Behaviour

Implemented all Art: 3D Models, UI, Textures

Grocery Odyssey was my first ever Game Jam I participated in during my 1st year at LCAD as a student. It was also the first time I had worked with a team and collaborated on a project, our team of 5 worked very well together and I learned a lot about communication inside a game-dev setting.

I had many personal goals going into the project which I succeeded in, that being: creating an interesting and fun game, implement cross-session data persistence, and winning an award. The award we won was "Best Sound Design." In which I implemented the sound.

Point & Click Combat System

Attack/Defend modes using only a single input

Type-based polymorphic enemy system

Data-Driven attack and combo framework

Involve the player moment to moment

Re-use level and combat components while keeping each encounter new/interesting

Multi-level game progression w/ increasing difficulty

JSON save system for cross-session data persistance

Unlockable final boss

Scriptable Object dungeon configuration

Progress the challange as the player gets better

Test the player with learned patterns and new patterns for the boss fight

Simple progression due to time-constraint

Led development from start to finish

Acted as Art Director guiding 2D and 3D artists to create assets aligned with a cohesive visual style.

Assigned tasks, delegated work

Maintained open communication and timelines to identify progress

Setup Team Sprints and co-ordinated members

Time constraints directed me to decide on a system that player's would already understand when going into the game

I eventually make the decision to go with Point & Click because it is understood widely across the gaming market and I knew with my skills I could certainly implement it.

In my experience I've learned how to use the Composition over Inheritence paradigm to structure my dependancies, using this I came up with the most time-efficient way to share behaviour, that being this typed based polymorphism, because it mocks a Strategy-Pattern-like Type composition. which is the most flexible.

This afforded me the ability to only manage one Enemy class in terms of functionality frameworking cutting down on code development time. A perfect solution for our time constraints and something I had the confidence to implement.

I decided on attacking & combos to keep in alignment with the mentality of re-usable systems construction.

Most importantly though, I created this system so I could compose the combos in the inspector without touching code. This had the intentional effect of specifically speeding up gameplay iterating. Very important for our small-time frame

During development I had set up each level as a seperate scene, which required me to go into each scene to configure their dependancies, variables, and prefabs. This was time consuming.

So I came up with the solution to have the configuration depend on an SO.

Since SO's live as an asset in the project window. I did not have to go into each scene and edit them, And I could modularly setup the config for any new levels in one location.

Although I did implement SO configuration, I realize in hindsight that I did not do it quick enough. Nearing the end I had some bugs that could have been easily solved had I had the S.O. configuration set up

Because I did not, the bugs took longer to fix at a crucial juncture of nearing our time limit

I now know that early configuration separation is highly important for SoC

JSON data persistence was a goal I had from the start of this project. I had done solo-research before hand and wanted to try my hand at implementing it.

I succeeded and now have more confidence in my ability to research, learn, and implement systems

If I was to do this project again, I would set up JSON saving before hand as a basis and debug that system so I don't have to implement the data saver, I can just implement my implementation of the data saver, which would speed up on development.

I learned the ins-and-outs of managing a team to create a complete product, this came with ups and downs and adjustments to our timeline. I can confidently say I can manage both myself and other members to come together in the end

Improvement-wise I could set up timelines more clearly and give resources to each individual so they can track them easier. This could be printing out a piece of paper with the timelines or having everyone set an alarm.

Cube Rabbit Adventure was a 6 week project made in a 4 person team consisting of me as the sole programmer and 3 other artists. My main goal with this game was to continue to increase confidence in my abilities to create complex systems within a deadline. The one I chose for this was the Leveling & Experience system.

I succeeded in this goal and managed to build the game around it creating a cool progression system with unique cosmetic rewards that look amazing in game (In my humble opinion).

Not only that, I had previously been trying to implement a small GOAP system, and once I completed my main goal, I pivoted to trying my hand at another GOAP system and was successful in implemented one for this game to. This elevated the experienced and gameplay and I am really happen with how it turned out.

Data-driven, event based level & experience system using Unity's UI World Canvas & UI Slider.

JSON saving of experience for cross-session progress persistance.

Increasing experiences per level

Levels unlock items

Event-Based Architecture

Cosmetic selection using UI Grid Layout Group tied to level up event progression w/ locked and unlocked states.

Cosmetic equipping reflected in character w/ smooth camera and UI transitions

Player-level based cosmetic unlocks

Fluid UI motion design transitions

Custom Goal-Oriented-Action-Planning (GOAP) system to dynamically determine AI course of action in real-time

Detector's poll or listen for event changes in world state to update Belief's

NPC's weigh potential actions based on beliefs, then chose an action to execute

Unity NAV-MESH Integration

GOAP Framework for complex descision making

Over time I've learned that hardcoding configuration into systems will be fast for the short term, but bad for the medium to long term. So one of my current philosophies when designing my systems it to make much of the configuration data-driven so I can change it when I eventually need to change something

Data-Driven architecture allows for quick A/B testing without ever touching code, speeding up playtesting during experiementation and prototyping.

Because this was a medium term project, I wanted to accomplish at least 1 significantly difficult goal, this was GOAP. Although there are solutions on the asset store I wanted to create one from scratch and use it as a learning experience.

GOAP allowed for the NPCs in the levels to dynamically respond to the player and dynamically utilize their surroundings creating simple but interesting gameplay loop without hardcoding anything.

With a GOAP framework complete, I could easily add more potential actions, beliefs, while using configuration data to change and test them without ever touching code

Because I was the only one in-engine I was tasked with leading the team's development. And since this was a 6-week project my responsibilities were different than say a 48hr game jam.

One example of my leadership would be the main character's (the bunny) design. I directly tasked and communicated with our character artist with coming up with different iterations on the design of the bunny. We would communicate over the week to finalize a design. I would critique and add questions to direct the visual design to where I needed it to be. In the end it turned out great.

During development I learned that I can very easily show my teamates progress I was making and ask for feedback.

Because is was a medium-term project I was able to procure feedback and make changes without needing to rush. Thus resulting in a better end-product