Projects |

Six Degrees

Mon, 01 Jun 2026 00:00:00 +0000

Six Degrees is a Hack ’n’ Slash action game built in Unreal Engine. Technical contributions focused on C++ gameplay systems, traversal mechanics, AI tuning, and plugin-level optimizations.

📸

🛠️ Key Technical Contributions

1. Traversal & Platforming Systems

Dynamic Traversal: Designed and programmed a Wall Running System in C++ inspired by Spider-Man Remastered.
Grappling Hook: Built a physics-based grappling hook using C++ and the Gameplay Ability System (GAS).
Platformer Actors: Created modular platformer actors in C++, including Infinite Sliding, Ziplines, and Spline Rails.

2. Combat System & Game Flow

GAS Combat Flow: Built combat flow logic using GAS, combining animation-driven combos, gameplay tags, and rotation locking for attack commitment.
QTE & Takedowns: Built a Quick Time Event (QTE) system and Spider-Man style cinematic takedown prompts in C++ triggered via renderer visibility checks.
Camera Volumes: Developed custom CameraMode Volumes in C++ with spring-arm easing to dynamically adjust camera behavior based on area context.

Smart World-Aware Traversal: Extended Unreal’s Recast NavMesh with custom smart-link traversal proxies and interfaces, allowing AI to automatically negotiate procedural jump-links via Motion Warped mantles (Short, Medium, Tall) and safe ledge jumps.
Spider-Man Combat Coordinator: Engineered a token-based combat role coordinator managing dynamic attack slots (Attacker, Flanker, Waiter, Supporter) and threat detection that triggers AI strafe-swaps and evasion when targeted by the player.
3D Flying AI: Developed 3D flight navigation with EQS combat repositioning, vertical Z-offsets, peer separation forces, and braking deceleration models.
StateTree & Decision Planning: Used Unreal’s StateTree for high-level decision making alongside Behavior Trees for GAS ability execution (migrated from an initial HTN evaluation).

4. Animation & Physics

Motion Matching & GASP: Integrated Motion Matching and GASP (Gameplay Animation Sample Project) in C++ for responsive, fluid locomotion transitions across all enemies.
Physical Animation: Implemented Physical Animation using RBWC (Rigid Body With Constraints) for realistic hit reactions and ragdoll blending.

5. Boss Encounters

Boss Fight Logic: Programmed combat loops, custom C++ tasks, and state machines for two boss encounters.
Phases & Scaling: Implemented phase transitions and dynamic attack scaling based on player health thresholds.

6. Non-Linear Quest & Dialogue System

FlowGraph Scripting: Created a branching Quest & Dialogue system using the FlowGraph plugin.
Custom C++ Nodes: Handled branching game states via custom C++ flow nodes linking NPC dialogue, encounter triggers, and quest persistence.
Documentation: Authored technical documentation outlining quest node creation for team designers.

7. Character Customization System

Mutable Integration: Built character customization features using the Mutable Plugin.
UI Integration: Integrated the customization backend with Common UI in C++ for menu navigation and mesh baking.

8. Performance & Optimization

13ms → 7ms Game-Thread Optimization: Slashed Game-Thread time by 46% using Unreal Insights and an automated in-engine profiling pipeline that executes headless benchmark runs and exports trace metrics.
Zero-Allocation & Time-Slicing: Optimized AI tick costs by eliminating per-frame heap allocations with pre-allocated evaluation vectors, frame-staggering expensive line-of-sight and ledge raycasts across ticks, and applying Significance Manager LOD scaling.

Forgotten Requiem

Thu, 20 Nov 2025 00:00:00 +0000

Forgotten Requiem is a singleplayer Diablo-like Action RPG (ARPG) built in Unreal Engine using C++ and the Gameplay Ability System (GAS).

👉 (Coming Soon)

🛠️ Key Technical Architecture & Systems

1. FlowGraph Quest & Cinematic Dialogue

25+ custom C++ Flow Nodes (dialogue, dialogue choice, cutscene, save game, spawn/alter enemies, apply gameplay effects, convert NPC to ally, etc.) drive a non-linear quest/dialogue graph that maps progress to GAS gameplay tags and player state, with a data-asset-driven camera preset/focus/shot system giving each dialogue node its own cinematic framing.

2. GAS Damage & Debuff Pipeline

A central UGameplayEffectExecutionCalculation (UCpp_ExecCalc_Damage) resolves Physical/Fire/Lightning/Arcane damage against per-type resistance attributes, applies radial falloff damage from an origin/inner/outer radius, and rolls elemental debuffs (Burn, Shock, Stun, Curse) plus several boss-unique status effects (Pandemonium, Pyre of False Comfort, Djinn’s Conduction Armor, Neural Dazzle) off a damage-type-to-debuff gameplay tag map.

3. Data-Driven Boss AI

A custom UBTTask_BlueprintBase task (UCpp_BTTask_BossBehaviorTask) turns boss combat into an author-defined state table: each combat state (melee/ranged combos, special attacks, stun, dodge, phase transform) lists distance-based conditions (in-range/closer-than/farther-than, or a Blueprint-custom predicate) that pick the next state — reshaping an entire boss fight is a data edit, not a C++ or Behavior Tree graph change.

4. Spatial (Ambient) Dialogue System

A data-driven system, independent of the main quest dialogue, where NPCs pick weighted in-world lines governed by a playback policy (repeatable / once-per-activation / once-per-combat / once-per-save with save-tagged persistence, priority interruption, anti-immediate-repeat).
A polymorphic USTRUCT-based trigger library (health-below-threshold with rearm, nearby-hostile-count with rearm, damaged-by-player, ability-used, ally-defeated, timed interval, gameplay event) covers combat and exploration contexts separately, so reactive barks need no manual per-encounter scripting.

5. Engine-Replacement Gameplay Subsystems

Shared Timeline Subsystem: A tickable world subsystem replacing per-actor UTimelineComponent usage with pooled, curve-driven timeline tasks (duration/ratio/loop/reverse modes) exposed to both C++ TFunction callbacks and Blueprint delegates.
Camera Subsystem: Composes independent base/offset values (mirroring GAS’s base/current attribute pattern) for zoom, pitch, and FOV on top of a third-party cine-camera plugin, each interpolating on its own timer.
Actor Pool Subsystem: Generic object pool for projectile/VFX actors that spreads pooled-actor destruction across frames to avoid a spike.
Ally Subsystem: Respawns fallen companions off-screen using async line-of-sight traces and navigation reachability queries, with separate in-combat/out-of-combat respawn delays.

6. Automated Test Harness & CI-Style Runner

A standalone test plugin (compiled out of Shipping/Test) layers Epic’s Automation Test Framework, CQTest, FunctionalTesting, and AutomationDriver over dedicated test game mode/instance/world fixtures, so every suite runs against disposable fixtures instead of production save slots or levels.
Real input, not mocks: a UI test drives the actual spell menu through IAutomationDriverModule’s async driver — moving the cursor to a rendered button’s hit-tested screen position, clicking it, then injecting a raw keyboard press through Slate — and asserts production Enhanced Input bindings activated the ability the UI just equipped.
Runtime Flow-graph fixtures: a quest test builds a UFlowAsset graph from scratch via reflection (FindFProperty/ContainerPtrToValuePtr to wire node connections that aren’t exposed to C++), fires 260 kill notifications through it end-to-end, and verifies completion state round-trips through an actual disk save — exercising the exact production Flow nodes, not stubs.
Functional-test actors: a checkpoint test spawns a real character and trigger volume and asserts on an actual physics overlap event, not a simulated one, checking save-to-disk and repeated-entry behavior.
Headless orchestration: a PowerShell runner launches UnrealEditor -game unattended, tails the live log file by holding a shared read handle while the engine process writes to it, streams pass/fail per test case to the console in real time, and emits HTML/JSON reports plus engine-side raw results — recovering partial results and marking the rest “not run” if the process crashes or times out.

7. Custom Unreal Editor Tooling

Interactive Viewport Gizmos: FComponentVisualizer subclasses with custom HComponentVisProxy hit proxies let designers click-and-drag individual patrol points directly in the viewport (HandleInputDelta/GetWidgetLocation), plus a dedicated spawn-radius visualizer for enemy spawners.
Blueprint Compiler Extension: A UBlueprintCompilerExtension hooks ProcessBlueprintCompiled to statically flag unsafe ability-delay usage at compile time — static analysis running inside the Blueprint compiler, not just runtime checks.
Custom Flow Graph Slate Nodes: Hand-built SGraphNode widgets (SCpp_FlowGraphNode_Dialogue, _DialogueChoice, _StartDialogue) swapped in via custom UFlowGraphNode subclasses so dialogue trees are readable at a glance in the graph editor.
Detail Panel Customization: An IDetailCustomization surfaces patrol data on the owning character’s details panel with custom row widgets and a clipboard transfer path that copies a patrol route struct from the component straight onto a Flow node.

Havoc

Tue, 01 Oct 2024 00:00:00 +0000

Worked on Havoc, a multiplayer team-based third-person shooter (TPS). Focused on building and optimizing UMG menu systems from Figma designs.

👉

🛠️ Key Technical Contributions

Figma Layouts: Built modular UMG layouts matching Figma designs and screen scaling specs.
Settings Persistence: Bound video, audio, gameplay, and keybind settings to C++ subsystems for dynamic updates and saving.

2. UI Performance & Optimization

Slate & UMG Optimization: Created C++ base widgets structured to avoid unnecessary pre-passes and redraw ticks.
Input & Navigation: Wrote keyboard and gamepad focus navigation handlers for submenus.

Junk! A Game About Robots

Mon, 01 Jul 2024 00:00:00 +0000

Worked on Junk! A Game About Robots, a robot fighting game. Responsibilities included building UMG menus, enemy AI, and a combat system using Unreal Engine’s Gameplay Ability System (GAS).

👉

🛠️ Key Technical Contributions

1. Gameplay Ability System (GAS) Combat

Modular Abilities: Built robot abilities (melee attacks, active abilities, defensive maneuvers) with GAS and network replication.
Gameplay Tags: Used GAS gameplay tags for ability states, cooldowns, and action cancelations.

2. Enemy AI

Behavior Trees & Perception: Built combat AI using Behavior Trees, Blackboards, and AI Perception to track targets and handle combat states.
Custom C++ Tasks: Wrote C++ tasks for AI attack evaluation and movement logic.

UMG Architecture: Created modular UMG widget classes for settings, gameplay HUDs, and garage configurations.
UI Optimization: Used delegate event listeners for UI updates instead of per-frame ticks.

Valor Arena: Wanderer's Struggle

Sat, 15 Jun 2024 00:00:00 +0000

A 3D wave-based survival action game developed in Unreal Engine 5.

🛠️ Technical Features

Combat & Gameplay Systems

Built modular combat systems including combo chains, ability triggers, stamina, and mana management.
Integrated animation-driven gameplay logic and combat state handling.

Rogue-lite Upgrade System

Built a wave progression system with randomized upgrade card selection.
Connected Blueprint UI systems with gameplay logic and data tables.

Enemy AI & Boss Design

Implemented enemy and boss AI using Behavior Trees, AI Perception, and custom tasks.
Designed reusable combat behavior frameworks for multiple enemy archetypes.

UI & Gameplay Feedback

Created gameplay HUDs, minimap systems, and progression interfaces using UMG.
Developed real-time UI updates synchronized with gameplay state changes.

Projects |

Six Degrees

🛠️ Key Technical Contributions

1. Traversal & Platforming Systems

2. Combat System & Game Flow

3. AI & Navigation Architecture

4. Animation & Physics

5. Boss Encounters

6. Non-Linear Quest & Dialogue System

7. Character Customization System

8. Performance & Optimization

Forgotten Requiem

🛠️ Key Technical Architecture & Systems

1. FlowGraph Quest & Cinematic Dialogue

2. GAS Damage & Debuff Pipeline

3. Data-Driven Boss AI

4. Spatial (Ambient) Dialogue System

5. Engine-Replacement Gameplay Subsystems

6. Automated Test Harness & CI-Style Runner

7. Custom Unreal Editor Tooling

Havoc

🛠️ Key Technical Contributions

1. Menu & UI Systems

2. UI Performance & Optimization

Junk! A Game About Robots

🛠️ Key Technical Contributions

1. Gameplay Ability System (GAS) Combat

2. Enemy AI

3. Menu & UI Systems

Valor Arena: Wanderer's Struggle

🛠️ Technical Features

Combat & Gameplay Systems

Rogue-lite Upgrade System

Enemy AI & Boss Design

UI & Gameplay Feedback