Information

January 2025 – Current

Hosted with Azure using Kubernetes and CosmosDB

From Wikipedia: “Assassin (also Killer) is a live-action game in which players try to eliminate one another using mock weapons, in an effort to become the last surviving player.” A charming game with an information management problem. Players require private information such as who their target is but to keep this information private, the game requires a host who cannot be a player in order to manage targets, points, etc. I solved this a few years ago by making a discordJS bot for my friend group to play. I figured this would be a good final project for my Cloud System Design class. It is still currently in progress as of 3/26/2025.

Despite growing up on games like Counter-Strike, I have never tried my hand at making a multiplayer shooter. I decided to come up with a simple premise and use my understanding of Unity 6 and Netcode for GameObjects to expand my understanding of the multiplayer implementations in shooters. Here is the premise:

The project will have two phases. The first phase of action will be a classic cowboy draw. Each player takes two shots to kill, so after this first phase one player is a single shot away from losing whilst the other has an advantage for the second phase. The player(s) that was shot gets teleported behind cover in one of the four corners of the level at random. This gives an interesting dynamic where one player has better positioning but only one health where as the other is out in the open but with full health. That’s it, a simple design but one that will be beneficial to my understanding of multiplayer programming.

Additional Credits

• Aaron Nguyen – Testing Help

This poker prototype was a school project for my Technical Design class at DigiPen. The project was created using a custom action system in order to quickly create polished looking gameplay for a simple poker-type game. It also has an automated play mode (activated by pressing “A”) which plays runs the game and selects random options for the player. This prints telemetry data to a CSV file when run as a PC build.

The following is a post-mortem I wrote as part of the assignment.

The project went very well! I found it a relaxing chance to practice Unity and found myself embracing the action list system alongside my usual Unity patterns. For example, I often use coroutines when doing things over time in my other Unity projects, however I found a nice balance of coroutines and actions to solve a lot of problems that I think would normally get solved by blocking groups within the context of this project. Now, when I return to my other games I find myself wanting to use actions as I really appreciate the speed they can be used to prototype ideas with a simple level of polish from the easing.

I wrote the game as an assignment without much organization for the structure of the code leading to most things being contained within the GameManager.cs file. This has already caused issues when trying to iterate towards the end of the project for anything related to gameplay. If I were to continue this project, refactoring the gameplay logic would be the first priority. I also considered the idea of using this as a base to build a little WebGL multiplayer poker game using Netcode for GameObjects which I think would work out well since I could just add RPC functionality to the actions and that would take care of a lot of the implementation.

Play the prototype below:

Splash Art by Vasiliki Makris

Information

August 2023 – April 2024

Engine: Unreal C++ and Blueprints

My Role: Producer and Programmer

Isshin is a lethal 3rd person action game focusing on the beautiful lethal dance of samurai-style combat. I am currently the producer on a team of 17 students where I am organizing cross-disciplinary work across art, audio, design, and tech. I am also a gameplay programmer using C++ and Blueprint in Unreal 5.2.

What I did on the project:

• General gameplay systems including interactions, dialogue, and progression
• Company game systems including using frame-data to automatically time Unreal montages for melee combat sequences
• God of War inspired enemy director and associated enemy behaviors
• Oversaw department schedules and kept everything on track with our production plan

Strike Back was my sophomore game project at DigiPen, created with a team of 19 students. I initially joined the team as a programmer; however, in the middle of the first semester, some interpersonal conflicts arose, leading the producer to leave the project. I didn’t know anyone on the team before joining, but despite that, they offered me the opportunity to take on the producer role. I was successful in facilitating cross-department communication and creating an achievable timeline after reducing the scope of the animation set. Despite numerous challenges, given the ambitious nature of the student project, we ultimately succeeded in creating a finished product of which we were all proud.

What I did on the project:

• Worked with a sound designer as the team’s audio programmer
• Created UI system and implemented most UI
• Implemented json-loaded scenes
• Created event system based on this
• Refactored the entire engine to use shared and unique pointers
  • This was done the summer after and made the game way more stable for publishing
• Created a generalized state machine system
• Integrated GGPO Multiplayer

Relevant Code Samples

Copyright © 2022 DigiPen (USA) Corporation.

ImGui Wwise Window

One of my jobs on the project was to implement the audio events created by our sound designer. However, there was no easy way to hear those events so I made this ImGui window that would read the header file that Wwise generates and create a list of buttons so each event could be previewed. This greatly helped with audio implementation and debugging.

namespace Editor::WwiseWindow
{
    // Initialize an input file stream for reading Wwise header file
    std::ifstream wwiseIDs;

    // Runs every frame ImGui updates the window. This code is only used in debug mode.
	// Open variable is unused as this code is only run when the window is open
    void Show(bool* open)
    {
        ImGui::Begin("WwiseWindow", open, ImGuiWindowFlags_NoCollapse);

        // Check if the file is open; if not, open the Wwise header file
        if (wwiseIDs.is_open() == false)
        {
            wwiseIDs.open("./Assets/Audio/Banks/Wwise_IDs.h");
        }

        // Check if the file is in a bad state such as if it reached the end of the file, and reset it if needed
        if (wwiseIDs.good() == false)
        {
            wwiseIDs.clear();
            wwiseIDs.seekg(0);
        }

        std::string myline;
        bool inEvents = false;

        // Read the file line by line
        while (wwiseIDs.good())
        {
            std::getline(wwiseIDs, myline);

            if (inEvents)
            {
                // Check if we're inside the EVENTS namespace. 
				// This is since the header file from Wwise contains a bunch of stuff other than events
                if (myline.find("namespace EVENTS") != std::string::npos)
                {
                    inEvents = false;
                    continue;
                }

                // Skip lines containing '{' or '}' as they are not events
                if (myline.find("{") != std::string::npos || myline.find("}") != std::string::npos)
                {
                    continue;
                }

                // Extract the event name
                std::size_t nameStart = myline.find("AkUniqueID") + strlen("AkUniqueID ");
                std::size_t nameEnd = myline.find(" = ");
                std::string name = myline.substr(nameStart, nameEnd - nameStart);

                // Create a button for the event
                if (ImGui::Button(name.c_str(), ImVec2(200, 20)))
                {
                    // Trigger the event using SoundManager
                    SoundManager::GetInstance().TriggerEvent(AK::SoundEngine::GetIDFromString(name.c_str()));
                }
            }
            else
            {
                // Check if we're entering the EVENTS namespace
                if (myline.find("namespace EVENTS") != std::string::npos)
                {
                    inEvents = true;
                    continue;
                }
            }
        }

        ImGui::End();
    }
}

Breach was my first semester project on team of three students. It is a co-op puzzle platformer where you play as two little robots trying to infiltrate the center terminal. It was inspired by Fireboy and Watergirl. I worked in an engine provided by DigiPen where I implemented different systems in C.

What I did on the project:

• Setup level creation system
• Designed and implemented all levels
• Created core gameplay objects
• Designed and implemented all UI

Team: Andrew Sumanto, Gavin Kay, and Griffon Hanson

Relevant Code Samples

Copyright © 2021 DigiPen (USA) Corporation.

Switch and Switchable Object

This project was the first time I was practically using C to make a game so it was a great learning experience that really accelerated my understanding of the language. This is some code that setups a “switchable” object like a door and a switch for those objects.

/**
 * Creates a Switchable object with the specified parameters.
 * 
 * @param type             The type of Switchable (enum SWITCHABLE_TYPES).
 * @param position         The position of the Switchable.
 * @param width            The width of the Switchable.
 * @param height           The height of the Switchable.
 * @param closedColor      The color when the Switchable is closed.
 * @param callbackOnTouch  The callback function to execute when touched.
 * @param moveDirection    The direction in which the Switchable can move.
 * @param keyType          The type of key required to activate the Switchable.
 * 
 * @return A pointer to the created Switchable.
 */
Switchable* CreateSwitchable(enum SWITCHABLE_TYPES type, Vector2 position, float width, float height, CP_Color closedColor, FunctionPtr callbackOnTouch, enum MOVE_DIRECTIONS moveDirection, enum KEY_TYPES keyType)
{
    Switchable switchable;
    switchable.type = type;
    switchable.moveDirection = moveDirection;

	// Setup the object collider and other properties
    Vector2 zero = CreateVector2(0, 0);
    switchable.collider = CreateCollider(position, zero, width, height, 1, 0);
    switchable.drawnPosition = position;
    switchable.triggerState = 0;
    switchable.closedColor = closedColor;
    switchable.key = keyType;

    // Check the type of Switchable
    if (type == SWITCHABLE_GAP)
    {
        switchable.triggerState = 1;
        switchable.collider->isTrigger = 1;
    }
    else
    {
        switchable.triggerSound = CP_Sound_Load("./Assets/silence.wav");
    }

    // Check if a key is required and if it's obtained
    if (keyType != KEY_NONE && IsKeyObtained(keyType))
    {
        switchable.triggerState = 1;
        switchable.collider->isTrigger = 1;

        switchable.triggerSound = CP_Sound_Load("./Assets/silence.wav");
        CP_Sound_Play(switchable.triggerSound);
    }

    switchable.callbackOnTouch = callbackOnTouch;

    // Add the created Switchable to the switchableList
    switchableList[numSwitchables] = switchable;
    numSwitchables++;

    // Return a pointer to the last created Switchable
    return &switchableList[numSwitchables - 1];
}

/**
 * Creates a Switch object with the specified parameters.
 * 
 * @param type             The type of Switch (enum SWITCH_TYPES).
 * @param position         The position of the Switch.
 * @param width            The width of the Switch.
 * @param height           The height of the Switch.
 * @param switchable       The associated Switchable.
 * @param timeInSeconds    The time interval for toggling the switch.
 * @param exclusive        Flag indicating if the switch is exclusive.
 * @param moveDirection    The direction in which the Switch can move.
 * 
 * @return A pointer to the created Switch.
 */
Switch* CreateSwitch(enum SWITCH_TYPES type, Vector2 position, float width, float height, Switchable* switchable, float timeInSeconds, int exclusive, enum MOVE_DIRECTIONS moveDirection)
{
	// Switch properties
    Switch switch;
    switch.type = type;
    switch.moveDirection = moveDirection;
    switch.pressedOriginalPosition = position;
    switch.exclusive = exclusive;

	// Setup object properties
    Vector2 zero = CreateVector2(0, 0);
    switch.collider = CreateCollider(position, zero, width, height, 1, 0);
    switch.drawnPosition = position;
    switch.triggerState = 0;
    switch.switchable = switchable;
    switch.toggleTime = timeInSeconds;
    switch.triggerSound = CP_Sound_Load("./Assets/Switch.wav");
    switch.unTriggerSound = CP_Sound_Load("./Assets/SwitchReverse.wav");

    // Check the type of Switch
    if (type == SWITCH_PRESS)
    {
        Vector2 offset = CreateVector2(switch.collider->point2.x, 0);
        switch.leftCollider = CreateCollider(add(&position, &offset), CreateVector2(0, 0), width * collisionWidth, height * collisionHeight, 1, 0);
		
        offset = CreateVector2(switch.collider->point1.x, 0);
        switch.rightCollider = CreateCollider(add(&position, &offset), CreateVector2(0, 0), width * collisionWidth, height * collisionHeight, 1, 0);
    }
    else
    {
        switch.leftCollider = NULL;
        switch.rightCollider = NULL;
        switch.collider->isTrigger = 1;
    }

    // Add the created Switch to the switchList
    switchList[numSwitches] = s;
    numSwitches++;

    // Return a pointer to the last created Switch
    return &switchList[numSwitches - 1];
}

Obscura is a puzzle-platformer in which the player uses different cameras to find colorful solutions to problems in a monochromatic world. The game was developed as a high school project by Griffon Hanson and Ty Morrow, and it won 7th place in the Computer Game & Simulation Programming event at the 2021 FBLA National Leadership Conference.

Everything the player sees is in black and white, but throughout the levels are cameras which display a primary color. Objects that match that primary color come into existence, which will allow the player to solve puzzles that they’d be faced with. However, they may also create objects that block the player’s path, maybe causing the player to leave a camera behind to hold a perspective that they wouldn’t be able to hold on their own. Obscura plays with perspective, platforming, and color as tools for creating an engaging experience for players. On top of this is the online leaderboard in which players race to climb for the top spot.

tOtgWGttVaREM:aVTA is an educational simulation for the purpose of informing travelling wizards magically trapped aboard enchanted locomotives on the processes of growing and selling vegetabullets to potential and perhaps unwitting passersby. Utilizing state of the art advanced aggressive sales tactics they will experience utilizing the power of “The Canon” in securing profit necessary for unlocking wards binding them aboard their prison. With enough practice, patience, and perserverence, any wizard who finds themselves in such a scenario will have a complete guide for getting off the road, and back to their tower where they can once again put down their roots and live a happy and fulfilling life!

The project was made on a team of five students with three programmers and two artists during the 2023 Global Game Jam. I took on much of the gameplay programming responsibilities and had a great time creating a little project. You can see a presentation of the game below.

Residuum is a multi-platform factory building simulation. The project’s main goal was to learn about AR, and how to integrate both a desktop and simulated version. The game was a high school project between myself, Travis Martin, and Ty Morrow. The music was created by me and can be found here.