Game Programming

Phase Runner

Phase Runner is a fast-paced 2D side-scrolling shooter where players dash through procedurally assembled level sections, switching between 10+ distinct weapons on the fly. The entire game — physics, weapons, level generation, and UI — was designed and built solo from scratch.

The hardest technical problem was the custom physics controller. Godot's built-in CharacterBody2D handles basic collision well, but the game required wall-jumping, coyote-time, variable jump height, and a zero-gravity dash that bypasses normal gravity for a precise window. I rebuilt the movement stack from first principles using move_and_slide with manual velocity management, giving full control over feel and making tuning fast.

Level generation uses a chunk-based system — prefab rooms are validated against a ruleset (no two spike corridors back to back, guaranteed weapon pickup cadence) and stitched together at runtime. This kept level design authored rather than fully random, so difficulty can be tuned without sacrificing the handcrafted feel.

• Shipped and publicly playable — live on itch.io
• Custom physics controller handling wall-jump, coyote-time, and invincibility dash without plugins
• Chunk-based procedural generation keeps levels varied while preserving handcrafted difficulty curves
• Full feature parity with original design doc — weapons, progression, level gen, leaderboard

VR Rhythm Game

This VR rhythm game puts the player inside a dragon — physical arm movements and body lean control flight direction while staying in sync with the music. Built for Meta Quest using Unreal Engine 5 and OpenXR. As Lead Programmer I was responsible for all gameplay systems, VR input mapping, and cross-team technical integration.

The core technical challenge was the dragon locomotion controller. Standard VR locomotion broke immersion; we needed the player's actual body pose to translate into dragon flight. I built a custom input aggregator in C++ that reads both hand controller orientation and head yaw simultaneously, blends them with a smoothing curve to prevent simulator sickness, and feeds the result into the flight physics. The threshold between "intentional tilt" and "natural head drift" required significant playtesting to tune.

Controller logic was implemented in C++ for deterministic per-frame execution at the physics tick rate. Blueprint was used for designer-facing tuning parameters — so the team could adjust sensitivity curves without touching code.

• Full playable VR demo delivered within the semester timeline
• Custom C++ locomotion controller — body-movement dragon flight with sickness-mitigation smoothing
• Led 2-programmer sub-team, reviewed all code submissions and resolved merge conflicts across 4+ contributors
• C++ / Blueprint split architecture — production-quality systems with designer-accessible tuning

Penguins Creed

Penguins Creed is a third-person stealth-action game built in Unreal Engine 5. The project focused on building the core enemy AI — patrol routes, a field-of-view detection cone with noise sensitivity, and an alert state machine — all implemented using UE5 Behavior Trees and Blueprint.

Enemy AI uses a hierarchical Behavior Tree with three top-level states: Patrol, Alert, and Chase. Patrol follows waypoints with idle wait times. The detection system uses a cone-shaped sweep with configurable angle and distance, checking line-of-sight via trace before triggering Alert. The Chase state applies NavMesh pathfinding with dynamic obstacle avoidance.

• Functional stealth loop — patrol, detect, alert, chase, and lose-sight return-to-patrol all working
• Configurable AI per enemy type — detection angle, speed, and aggression tuned per Blueprint instance
• Smooth third-person movement with blended animation states for walk, sprint, crouch, and jump