HeXpunk

Building on Common UI, I implemented a dynamic widget stack system to manage layered flows for menu and gameplay UI, including modals and overlays. This system standardized how widgets were opened, closed, and layered on the viewport, ensuring consistent focus and predictable behavior. I fine-tuned Unreal Engine’s DPI scaling system and adjusted the UI scaling ratio so that all menus, prompts, and in-game UI elements displayed comfortably across a wide range of screen sizes and resolutions. Since all other widgets would be contained within these stacks, they inherited correct proportions automatically.

The stack architecture made it easy to add new menus, overlays, or in-game prompts in the future without duplicating logic, supporting a clean and modular codebase that other programmers could work with efficiently.

I implemented a lightweight camera manager responsible for controlling menu background presentation. Rather than tying camera logic directly to individual menus, this system allowed menu states to request specific camera setups and level sequences, enabling clean transitions between visual scenes such as the title screen, main menu, and character select screens.

The camera manager handled swapping between background scenes and level sequence playback as menus changed. By modularizing these transitions, UI logic remained focused on input, navigation, and layout, while visual presentation was handled independently. This made it easy to introduce new menus or visual variations without duplicating camera or sequence logic.

I created a reusable set of modular widgets to support menus and interfaces. Buttons were designed to handle hover, focus, and click states consistently, including dynamic input icons that changed in real time depending on the active device. A tab switcher allowed users to navigate between Settings pages and Gallery interfaces while maintaining persistent focus. Editor widgets, including sliders, rotators, and toggles, bound dynamically to data and supported reliable apply, cancel, and reset workflows. I also developed an action bar system for contextual in-game actions and menu interactions. This modular architecture allowed me to efficiently implement new menu screens such as the How to Play, Settings, and Pause Menus without duplicating code or introducing inconsistencies.

The Main Menu builds on the Title Screen with a cinematic level sequence I created that showcases the two playable characters under custom lighting and animation poses provided by the artists. Buttons and navigation elements feature consistent hover states, controller focus handling, and subtle animations for a professional feel. These systems formed the foundation for the rest of the game’s UI by establishing consistent behavior for transitions, input switching, and menu presentation.

I created a dedicated character selection manager to coordinate camera transitions, character visibility, and player input. To ensure smooth and intuitive input support, I built logic for both controller and keyboard/mouse users. On controller, players could rotate characters using the right analog stick and select characters with minimal confirmation steps, while mouse users could drag to rotate and select a character button or the character mesh itself. Early builds revealed issues with input detection and navigation clarity. I fixed initialization logic so correct device prompts appeared as soon as a menu opened, not just after input changes. Dynamic action bars were implemented to display relevant button prompts without clutter.

The Character Select screen underwent several layout and style iterations to balance readability, visual hierarchy, and consistency with other menus. The menu started as a combined character and weapon selection menu before the weapon choice feature was scoped out to simplify the player experience. A later version used modular character button widgets with dynamic highlights, ability icons, and text entries arranged on either side of a centered character. While functional, this layout conflicted with other menus and felt visually cluttered.

Through iterative refinement, I reorganized the interface to clearly present character names and abilities, streamlined highlight and hover states for both controller and keyboard/mouse, and established a consistent design language across all menus.

To enhance immersion, I designed a custom scene for the final Character Select screen, using assets from the main game to create a narrative moment of the heroes preparing to leave for a mission. I built a level sequence that played after selection, featuring a van starting, driving away, and transitioning seamlessly into the Loading screen. These narrative flourishes added polish and reinforced story context, elevating the menu experience to feel like part of the game’s world rather than a static interface.

To keep asset management flexible, I built a custom structure and data table to store all Gallery item details, including meshes, materials, scaling adjustments, and camera settings. A dedicated inventory widget dynamically populated slots based on this table, allowing easy updates without modifying blueprint logic. Each slot widget included hover states, selection logic, and focus-handling for both controller and keyboard/mouse users. I also created a scaling helper formula so assets of varying sizes would remain consistent.

The Gallery was designed to feel natural for both controller and keyboard/mouse users. On controller, players can rotate items smoothly with the right analog stick and zoom in or out with the triggers. On PC, clicking and dragging the mouse rotates the camera, while the scroll wheel adjusts zoom. Achieving smooth and responsive controls required careful blueprint logic to separate stick inputs into horizontal and vertical movement, apply dead zones, and fine-tune camera behavior. All inputs were mapped into the action bar, which dynamically displayed the correct button prompts without cluttering the interface. I also implemented a toggle to hide the UI elements.

To standardize UI icons across the Gallery, I built a blueprint-driven, camera-based render pipeline using Render Targets. This setup allowed batch export of consistent, high-quality thumbnail textures with minimal manual adjustments. Orthographic cameras and fixed framing rules ensured visual consistency across 50+ assets. I documented the process and trained a teammate to assist, making updates faster and reducing production overhead.

To avoid hardcoding each setting, I created reusable editor widgets (sliders, rotators, toggles) that dynamically bind to values and communicate with a persistent and centralized Save Game structure. This unified system allows settings to be applied, canceled, or reset reliably, whether in-game or from the main menu, with immediate feedback. The architecture is modular and scalable, making it easy to add new options or expand functionality in the future. I also leveraged Unreal Engine’s Common UI plugin to simplify multi-device input navigation and controller support, enabling a polished layout comparable to professional titles.

I implemented a full suite of video options, including resolution, window mode, FPS limits, scalability presets, vertical sync, and resolution scaling. To streamline functionality, I moved away from duplicated switch statements and instead used data tables and structures to populate rotator selections dynamically. Scalability presets could automatically update dependent sub-settings, while a custom “Custom” option reflected manual adjustments. Managing dependencies, like disabling V-sync for incompatible window modes, required careful blueprint logic. I also addressed quirks between editor and packaged builds, particularly for resolution scaling, ensuring a consistent experience across environments.

I implemented a description box that dynamically updates when a user hovers over or selects a setting, providing concise explanations of each option. This enhances accessibility, helping players of all ages and experience levels understand the function of settings like sensitivity, inversion, or graphics presets. By integrating it with all editors, it ensures users can make informed adjustments without trial-and-error, improving overall usability and clarity.

Early in development, I established all of the required sound effects in the teams asset tracker, categorizing nearly all sound effects required for a polished final experience. Sounds were grouped by gameplay function, system ownership, and implementation complexity, which helped guide prioritization and ensured coverage across UI, characters, enemies, abilities, environment, and feedback systems. From the outset, I identified sounds that would benefit from synthesis or procedural generation versus a pure sample-based design.

I sourced the project’s sound effects through a combination of curated free asset packs and my personal sound library, resulting in a collection of approximately 1,200 samples organized across 68 folders. All material was selected to be royalty-free, ensuring originality and suitability for a commercial Steam release. Many samples served as raw building blocks rather than finished assets, chosen for texture, timbre, and layering potential instead of direct usability. By treating samples as components rather than final sounds, I maintained consistency across the project while avoiding repetitive or static audio playback.

Sound effects were integrated directly into gameplay systems to improve responsiveness, spatial awareness, and overall game feel. I implemented animation notifies across both character and enemy animations to trigger sounds with precise timing, including footsteps, attacks, jumps, damage, and death events.

For footsteps, I built a dynamic system combining animation events, line traces, and physics materials to determine surface type and spatial placement. MetaSounds were authored for each surface category, and physics materials were applied to walkable surfaces to ensure correct audio playback throughout the environment.

Enemy audio, particularly footsteps and attack cues, was designed to support gameplay awareness by providing clear positional and timing information, allowing players to anticipate threats even when enemies were off-screen.

To support scale and maintain clarity as the project grew, I designed a structured audio architecture built around sound classes, sound class mixes, submixes, concurrency assets, and attenuation profiles. Sounds were categorized by function, such as UI, combat, environment, feedback, voice, and music, enabling targeted processing, balancing, and mix control. These categories were also exposed to the settings menu to allow user-adjustable audio control.

I created and carefully tuned attenuation profiles by listening for how sounds read at different distances and angles, adjusting falloff and spatialization until movement, combat, and environmental audio felt natural across the space. I also tuned concurrency limits to avoid audio spam during dense gameplay moments, maintaining clarity without cutting off important feedback. For the Manacore factory interior, I added a reverb volume to reinforce a sense of scale and enclosure, helping the environment feel distinct from exterior areas.

Final mixing and loudness balancing were handled perceptually, with additional tuning passes once systems began overlapping in gameplay. I tested across multiple playback devices, including headphones, speakers, TVs, and monitor audio, to identify outliers and achieve consistent results.

I implemented a dedicated health-based audio feedback system to improve gameplay clarity during high-stress moments. This included a dynamic heartbeat MetaSound paired with a low-pass filter driven by control buses and modulation. As player health decreased, the heartbeat’s volume and pitch intensified while the audio mix subtly filtered, reinforcing danger without becoming disorienting.

This audio feedback was paired with a subtle red gradient screen-edge effect on the player HUD that pulsed in sync with the heartbeat, providing cohesive audio-visual feedback. The system was implemented as a reusable actor component attached to the base character and integrated with existing health events.

I built a modular interactable item system for all interactable objects throughout the map, capable of dynamically selecting meshes and associated audio behaviors. I fine-tuned physics behavior ensuring consistent collision response, displacement, and audio feedback.

Each object was assigned appropriate physics materials and Metasounds to drive correct impact sounds based on material type. Impact sounds were driven by collision thresholds, with volume scaled by impact force and pitch randomized for variation. This approach allowed a single system to support a wide range of interactable props while maintaining believable physical response and audio consistency.

I composed multiple early drafts of both menu and gameplay music in FL Studio, using the menu theme as a lower-risk space to experiment with production techniques, instrumentation, and structure within a genre I had not previously worked in extensively.

Early versions leaned too heavily toward metal influences, relying on aggressive textures and instrumentals that did not fully support the game’s punk identity without vocal elements. Through iteration and multiple feedback sessions, I refined the arrangement, rhythm, and sound palette to emphasize groove, attitude, and motion over sheer intensity.

To better define the musical direction, I researched multiple punk subgenres and adjacent electronic influences, building reference playlists and analyzing structure, sound design, and energy flow. Feedback sessions helped narrow the direction toward a sound that felt more playful, stylized, and rebellious rather than dark or oppressive.

Tracks such as Paint the Town Blue by Ashnikko and Generator by Justice became key reference points, helping inform tone, pacing, and sonic texture while still allowing room for original composition and sound design.

I mastered the final music in FL Studio, then implemented in Unreal Engine with smooth fade-in and fade-out behavior when entering and exiting menus. Music levels were balanced in-engine and routed through the game’s audio settings, allowing players to independently control music volume alongside other sound categories.

Music developed during earlier feedback sessions was repurposed for the multiplayer lobby, maintaining tonal consistency while avoiding unnecessary asset waste.

I defined enumerations to represent damage types, damage responses, and status effect types, allowing behavior to branch based on intent rather than hardcoded checks. Supporting structures encapsulate all damage and status data, keeping function signatures clean and scalable as new parameters were introduced. This allows weapons, abilities, and pickups to communicate intent without needing to understand the internal logic of the health system itself.

The core logic lives within a reusable Health System Actor Component. This component manages current and maximum health, death handling, healing, and the application of status effects. It exposes many event dispatchers that notify interested systems when key events occur, such as health changes, damage taken, death, or status application. This event-driven design allowed AI, UI, VFX, and gameplay logic to respond independently without tightly coupling systems together.

The component also includes support for future-facing mechanics such as blocking, interruption, and invincibility, which were designed into the system even though they were not fully explored during production.

I implemented a base Status Effect Actor Component that defines shared behavior such as duration handling, looping ticks, and cleanup. Specific effects such as poison and stun were implemented as child components, enabling per-effect customization while sharing common lifecycle logic.

Poison applies damage at fixed intervals, while stun leverages the base functionality without additional logic. I created temporary Niagara systems to visually represent active effects and provide a foundation for artist iteration.

I integrated the system into both the base AI and base player character, with each binding to health system events to handle reactions such as UI updates, behavior changes, and ragdoll behavior on death. Weapons and abilities were updated to apply damage and status effects exclusively through interface messages, ensuring consistent behavior and making effects easy to tune or toggle during testing. For debugging and behavior testing I created and implemented a temporary world-space enemy health bar.

To avoid breaking existing gameplay logic, and to ensure the system could be adopted smoothly by the rest of the team, I audited the project and replaced references to the previous health implementation with the new interface-driven system. After completing the work, I walked the other programmers through the architecture during a stand-up meeting, explaining how to apply damage, healing, and status effects correctly when implementing new gameplay features.

I crafted and integrated a set of behavior tree tasks and services to support enemy decision-making and state updates. These tasks were used to control movement, attacks, and behavioral transitions, forming the backbone of the enemy AI’s decision flow.

I was tasked with improving the core behavior tree for the basic melee enemy through extensive experimentation and playtesting. This process involved refining navigation, perception, EQS usage, and state transitions to improve responsiveness and reduce edge cases and create more engaging enemy behavior during combat encounters.

I created a Blueprint Interface to define shared functionality for enemy actions such as setting movement speed, triggering attacks, and playing idle animations. This interface allows behavior tree tasks and controlling systems to communicate with enemy pawns using message-based calls, avoiding direct casting and reducing coupling between systems.

Functions exposed by the interface can be overridden by child enemy classes, enabling variation in behavior while maintaining a consistent control surface. This approach keeps behavior trees flexible and reusable across multiple enemy types.

Using the enemy core interface and custom behavior tree tasks, I implemented attack logic that supports multiple attack animations. Attacks are triggered through animation montages, with damage applied via a collision box activated by animation notify events. This ensured tight synchronization between visuals and gameplay impact.

Player feedback was refined through knock-up reactions on hit, and I assisted another programmer on the team in improving the damage popup system so that damage numbers visually reflected damage types, improving combat readability.

I imported the Paragon Rampage skeleton and animations and retargeted them to the custom grunt skeleton model created by a member of the artist team. Using Unreal Engine’s IK Rig system, I created IK rigs for both source and target skeletons, auto-generated retarget chains, and then carefully refined them by realigning bones, adjusting pivot points, and configuring IK to ensure accurate and natural motion.

I exported the animations and integrated them into the Base AI Animation Blueprint. This included setting up default and upper body slots to support blended animation montages, updating blend spaces, and ensuring death and locomotion animations were consistent across enemies. The process significantly improved animation quality and workflow efficiency for future asset imports.

I created a comprehensive Notion document outlining Perforce usage and revision practices, folder structure conventions, naming standards, and blueprint commenting guidelines. This document was shared with the team to ensure consistency and reduce errors during development.

Throughout development, I organized project folders and asset prefixes, removed redirectors, and updated asset tracking information. These efforts maintained a clean, navigable project structure, supporting faster iteration and smooth collaboration.