Purple Glow

A first-person action shooter developed in Unreal Engine with C++, featuring momentum-based slide mechanics, hybrid raycast-projectile weapons, state-machine enemy turrets, and procedural room generation.

UnrealC++Game

Overview

Purple Glow is a fast-paced first-person action shooter built in Unreal Engine using C++ for all core gameplay systems, AI states, and procedural level-generation tools, paired with Unreal Blueprints for UI widget binding.

Tools & Technologies: Unreal Engine, C++, Unreal Motion Graphics (UMG), Blueprints

Technical Contributions & Granular C++ Systems

1. Momentum-Based Player Movement Controller

  • Velocity-Aware Slide & Crouch Logic: Extended the C++ character movement component to support sprinting, crouching, sliding, and slide-jumping. When the crouch input is triggered, the controller evaluates the player's current velocity vector to determine whether to transition into a standard crouch or initiate a high-speed momentum slide.

2. Hybrid Raycast-Projectile Weapon Architecture

  • Modular Weapon Class Hierarchy: Decoupled weapon logic into dedicated C++ weapon classes referenced and swapped dynamically by the player controller.
  • Screen-Center Line Trace + Physical Projectiles: Engineered a hybrid firing solution that performs a camera-center line trace to calculate exact target convergence regardless of proximity, then spawns physical projectiles along the corrected vector to deal damage.
  • C++ to UMG Data Binding: Exposed BlueprintCallable C++ getter functions for active ammo counts and weapon states to drive real-time HUD widget updates.

3. State-Machine Enemy Turret AI

  • Four-State Autonomous Turrets: Programmed enemy turret actors in C++ operating across four discrete states: Search, Aim, Firing, and Reloading.
  • Cone Overlap & Line-of-Sight Validation: Utilized a vision cone overlap component to detect player entry, followed by an occlusion line trace to verify the player is not behind cover before transitioning to the Firing state.

4. Decoupled Health, Score & Time-Multiplier Systems

  • Reusable Health Actor Component: Built the health system as an independent C++ class attachable to both the player controller and enemy actors.
  • Time-Linked Score Multiplier: Integrated GetWorld()->GetTimeSeconds() directly into the C++ score manager so level completion speed dynamically scales the player's active score multiplier.

5. Multi-Condition Door & Interaction Pipeline

To control level pacing without writing bespoke scripts for each room, I built a unified C++ door controller configurable via editor properties:

  • Configurable Unlock Conditions: Supports opening via target-hit thresholds, specific keycard IDs, trigger-box presence, or direct player interaction.
  • Controller-Managed Interaction Array: When a player enters a door's trigger volume, the door registers itself in an active interaction array on the player controller. Pressing the interact key iterates through the registered array and invokes CheckDoorInteraction() to validate unlock criteria.

6. Polymorphic Pickup Hierarchy

  • Base & Child Pickup Classes: Created a base C++ pickup actor handling mesh rotation and collision setup, with specialized child classes overriding OnOverlapBegin to either restore player health via the health component or register specific KeyID values on the player controller.

7. Procedural C++ Wall & Room Generators

  • Parametric Level-Building Actors: Wrote C++ construction tools capable of procedurally spawning cube arrays and complete 4-wall room layouts based on configurable width, height, length, per-instance material assignments, and spatial offsets.

Direct Impact

  • Modular C++ Foundation: Separating health, weapons, pickups, and doors into reusable, data-driven C++ classes allowed level designers to assemble complex combat rooms and puzzle gates directly in the Unreal Editor without duplicating code.
  • Responsive Gunplay & Movement: Combining velocity-checked slide-jumping with hybrid raycast-projectile targeting delivered accurate, high-speed FPS combat.