Projects.

Part-time Game Developer at Liquid Metal Games on Ruinous Hunter, a dark fantasy Soulslike about a memory-stricken mercenary who recovers fragments of his past by defeating bosses, each memory unlocking new powers. Focused on combat, traversal, and AI systems.

• Developed gameplay systems in Blueprints, C++, and GAS including health/shield/stamina, and hit reactions.
• Implemented player combat including dashing, dodging, multiple weapon types with equip/unequip, projectiles, and socket-based weapon attachment.
• Built traversal and movement systems including mantling, camera shake, and level transitions.
• Improved FPS by 20-30 frames by implementing distance-based rendering for foliage.
• Programmed enemy AI with patrol behaviours, death logic, and combat interactions.

A Mario-inspired platformer built in Unity featuring a full lava-themed level with 10+ enemy types, interactive hazards, and custom gameplay systems.

• Designed and built a lava level with hazards like Podoboos, Roto Discs, Thwomps, and Spikes.
• Programmed enemy behaviors - Dry Bones, Goombas, Piranha Plants, and the Donut Lift platform.
• Implemented interactive systems: Question Mark blocks, hidden item boxes, coin-to-block toggle switch, and power-ups (One-Up, Flower Power).
• Rebuilt some of the same enemies in Unreal Engine to learn how Unreal handles platformer mechanics.

A top-down tower defense built in C++ on a small OpenGL framework. Place towers and walls to shape the path enemies take, then survive five waves that get harder each round.

• Built a 5-wave system with faster spawns, tougher enemy mixes, and a short break with a coin bonus between waves.
• Added three placement modes - tower, wall, and sell - with sell refunding coins and recalculating enemy paths.
• Made three enemy types (Basic, Fast, Tank) each with their own speed, health, and damage values.
• Wrote a player health system that drains when enemies reach the end and triggers game over at zero.
• Built ImGui HUD showing wave progress, coins, kills, and a color-shifting health bar.
• Added win and game over screens with restart and menu buttons.

A C++ game engine built from scratch over a semester, growing from a rotating cube to a full 3D scene with terrain, physics, and lighting.

• Built an entity-component system with scenes, game objects, and a component manager.
• Wrote a resource manager that handles meshes, textures, shaders, and materials.
• Wrapped Box2D and Jolt Physics behind a single interface so 2D and 3D scenes share the same physics calls.
• Loaded OBJ models and built a heightmap terrain mesh from a PNG, with barycentric sampling so the player walks on the surface.
• Wrote a multi-light fragment shader that picks the closest 8 lights per object each frame.
• Added a free camera with mouse look and keyboard input.

A 2D platformer level designed in Unreal Engine 5 with 12 interconnected rooms featuring platforming, combat, puzzles, and parkour challenges.

• Designed 12 interconnected rooms with distinct challenges - platforming, combat, puzzles, and parkour.
• Planned and tuned difficulty curve using a pacing chart across all rooms.
• Ran playtests, collected feedback, and iterated - replaced a frustrating spike section with a more balanced design.
• Produced full documentation: mini-map with legend, pacing chart, and playtest analysis.

A top-down stealth game in Unity where players sneak past enemies using distractions and cover. Features enemy FOV cones, fog of war, and 3 levels with increasing difficulty.

• Top-down 2D stealth game with enemy field-of-view detection and fog-of-war systems.
• Implemented distraction mechanics for player interaction and strategic gameplay.
• Built three playable levels with a main menu interface.

A top-down survivors-style shooter made in C++ using a 2D game framework. Enemies spawn in waves and the player's weapons fire on their own. Killing enemies drops XP balls, and picking them up makes the weapons stronger.

• Two auto-firing weapons - one shoots at the closest enemy, the other fires a ring of bullets around the player.
• XP balls drop when enemies die and speed up the weapons when picked up.
• Two enemy types with their own speed, health, and animations.
• HUD shows XP, kills, and time.

A top-down arcade racer built in C++ using a 2D game framework. Drawn entirely with basic shapes for a retro look.

• Built car physics with smooth acceleration, braking, and wall bouncing.
• Made a reusable Tween class for animating pickups, menus, and race results.
• Added a lap timer that tracks your current and best lap.
• Included oil slick hazards, collectible pickups, and an F1 debug overlay.

A collection of arcade-style minigames built in Unity using UI Toolkit.

• Built 12 arcade minigames in Unity with a central hub for navigation between games.
• Designed per-game color themes using UI Toolkit (UXML/USS) with consistent styling across all screens.
• Implemented persistent high score tracking for each game using PlayerPrefs.

A player-vs-AI tank game in Unity where the AI uses a behaviour tree to hunt down the player's detonator.

• Built a behaviour tree with custom action nodes for turret aiming, shooting, and tank movement.
• AI scans and shoots barrels to uncover hidden detonators, prioritizing the player's over its own.
• When the player's detonator is exposed, the AI switches to a chase strategy and tries to run it over.
• Used a blackboard to share game state between nodes (barrel list, detonator positions, tank status).
• Made the AI defend its own detonator when revealed and time shots around a 0.4 second cooldown.

A player-vs-AI slot car racer built in Unity on a figure-eight spline track.

• Laid out a figure-eight track using Catmull-Rom splines with two parallel paths.
• Built AI driving logic that samples ahead on the spline to detect sharp corners and adjust speed automatically.
• Added crash detection based on corner radius - exceeding the speed limit sends the car into a spin.
• Implemented player controls with acceleration, braking, and a spacebar reset for crashes.
• Displayed per-car lap count, speed, crash state, and a winner screen on the HUD.

A classic arcade Asteroids made in C++ using a 2D game framework. Built as a single-player score run where you clear 20 asteroids to win.

• Created a triangle-shaped player ship with input driven movement and Spacebar shooting.
• Implemented 20 asteroids that destroy in one hit, with collision detection against the player and bullets.
• Programmed player death and respawn logic when an asteroid hits the ship.
• Added screen-wrap behaviour so the ship, bullets, and asteroids re-enter from the opposite side when they leave the play area.
• Designed a shield pickup with a 1 in 7 drop chance from destroyed asteroids.
• Built a game-won text screen that triggers once all asteroids are cleared.