As a Gameplay Programmer, I was responsible for implementing key functionality that supported the core game experience.
My main contributions included:
Light detection mechanics – implementing systems where player interactions and behaviors were influenced by lighting conditions.
Core movement functionality – developing responsive and reliable player movement.
Interaction system – enabling players to interact with objects and the environment seamlessly.
Menu systems – implementing in-game menus and UI functionality for a smooth player experience.
General gameplay features – contributing to the implementation of mechanics that shaped the overall gameplay loop.
Biplo Restoration Services
In addition to gameplay programming, I also took on important project support roles:
Build Manager – responsible for managing builds and fixing technical issues during the build process.
Git Manager – maintained version control by resolving merge conflicts, fixing Git issues, and ensuring smooth collaboration across the team.
This project was completed as part of a team of eight, collaborating closely with designers, artists, and programmers to deliver a client-facing game for Konglamorate Games.
Mechanic Breakdown/Implementation
Dynamic Light Detection System:
For this project, I implemented a light detection system to drive core puzzle mechanics. My goal was to accurately determine if the player was standing in an illuminated area to trigger specific gameplay scenarios.
My initial approach involved designer-placed collision volumes, but this proved inefficient, as it required static lighting and an immense amount of manual setup.
I then attempted a raycasting solution, but this became computationally expensive and failed to account for global illumination or light falloff.
The final implementation utilizes a render target approach inspired by pixel brightness manipulation. I attached a camera to the base of the character mesh, looking downward to capture the lighting below the player (with their model and shadow hidden). By capturing this view into a UTextureRenderTarget2D, I can access the raw pixel data. The system iterates through the texture array on the CPU, calculating the luminance of every pixel using the standard formula
Performance & Retrospective Since the pixel iteration occurs on the CPU, optimization was critical. I limited the capture resolution to 100x100 pixels, which provided sufficient data accuracy without causing a bottleneck on the main thread. However, looking back at the architecture, moving this logic to a Compute Shader would be the ideal optimization. Offloading these parallel calculations to the GPU would drastically reduce CPU overhead and allow for higher frequency checks.
Another mechanic I developed was a hybrid camera system that dynamically switches between a standard third-person mode and a cinematic spline-based track depending on the level requirements. The goal was to allow for tight, directed framing in specific environments without taking control away from the player.
The system checks level data upon initialization. If a spline path is detected, the camera enters a constrained state where it detaches from the player's control rotation. In the update loop, I calculate the position on the spline closest to the player's world location using FindLocationClosestToWorldLocation. The camera smoothly interpolates to this new position while simultaneously calculating a look-at rotation to keep the player centered in the frame.
This approach solved the issue of camera occlusion in tight corridors by forcing the perspective along a designer-defined path. Additionally, I implemented logic to detect when the player reaches the end of the spline, seamlessly blending back into the standard spring arm attachment for free camera control.
Hybrid Spline Camera System
A core philosophy in my gameplay programming is ensuring that mechanics are easily tunable by level designers. I explicitly avoid hard-coding values inside the logic, instead exposing key gameplay variables directly to the Unreal Editor. This allows the design team to iterate on the game feel rapidly without requiring constant code recompilation or programmer intervention.