Dominic Barbuto
Gameplay Software Engineer
NULLSPACE is a cyberpunk-inspired arcade shooter that places players in traditional multiplayer maps with a variety of lane layouts. The game features traditional multiplayer modes such as Deathmatch, Team Deathmatch, and Data War (our unique take on Capture the Flag). Players have access to a wide array of weaponry, equipment, and power-ups, as well as levels featuring vastly different obstacles and pathways that incentivize both teamwork and rogue play. This is my company, Domension Studios LLC's, first major title.
Engine | Unreal Engine 5 (C++)
Team Size | 3+
Roles | Creative/Technical Director and Lead Developer
Play Time | Unlimited (Multiplayer)
Purchase and Download |
Steam
Platform | PC
Duration | 06/2024 - Present (2+ Years)
Website |
Table of Contents
- Gallery
- My Role and Responsibilities
- Unique Main Menu Setup: Level Streaming and Dynamic Background
- Character Locomotion: Omnidirectional Movement
- Matchmaking Menu: Server Browser
​- Obtaining Authentic Footage in Real Multiplayer Matches for Marketing
My Role
As the Lead Programmer and primary technical developer for NULLSPACE: DATA WAR, I have been responsible for the game's technical development from its core gameplay systems to its multiplayer architecture and Steam release preparation. I designed and implemented the majority of the game's systems in Unreal Engine 5 using C++, with a particular focus on multiplayer networking, gameplay architecture, character and weapon systems, UI, and game-state management. Beyond feature development, I have also taken ownership of technical debugging, packaged-build stability, Steam integration, and architectural decisions throughout development, effectively overseeing the game's programming and technical direction from development through Early Access preparation.
​
Aside from development, I very much enjoyed coordinating and organizing public playtests to gather feedback from real players. I also created PowerPoint presentations for each playtest, which served as a game plan and guide for each session. Through our Discord community, I've had dozens of players help us identify and fix bugs, as well as capture in-game footage for media and marketing purposes
Responsibilities
As the lead programmer and primary technical developer for NULLSPACE: DATA WAR, I have been responsible for designing, implementing, and maintaining the game's core gameplay and multiplayer architecture in Unreal Engine 5.
-
Multiplayer Architecture — Designed and implemented the authoritative client/server architecture, including replication, RPCs, PlayerStates, GameStates, seamless travel, network ownership, and server/client synchronization.
-
Gameplay Systems — Developed the core gameplay systems for Deathmatch, Team Deathmatch, and Data War, including match flow, objectives, scoring, damage, elimination, respawning, and player interactions.
-
Character & Player Systems — Built the character selection, player spawning, team assignment, character persistence, and player-state systems supporting multiple playable characters.
-
Weapon Systems — Developed and maintained weapon selection, persistence, hitscan and projectile weapons, damage processing, hit detection, and weapon-related gameplay systems.
-
Lobby & Team Systems — Created the multiplayer lobby, player slot management, team assignment, team-specific character selection, and lobby-to-match transition systems.
-
Match Flow & Game State — Implemented the complete multiplayer match lifecycle, including lobby, warmup, active match, cooldown, and custom match restart systems.
-
UI & HUD Programming — Developed gameplay and lobby interfaces in UMG, including the character selection system, dynamic background cutscenes for the main menu, matchmaking (Quick match, Server browser, Host Match) menus, interactive gameplay widgets, and a replicated multiplayer scoreboard.
-
Steam & Input Integration — Integrated Steamworks functionality and developed custom Steam Input integration alongside Unreal Engine's Enhanced Input system for keyboard, mouse, and controller support.
-
Physics, Collision & Animation — Implemented and debugged projectile collision, hitscan detection, skeletal mesh collision, Physics Assets, gameplay physics, character animations, death sequences, and hit reactions.
-
C++ Game Architecture — Built reusable gameplay systems and components primarily in native C++, integrating them with Unreal Engine's Blueprint framework where appropriate.
-
Technical Debugging & Optimization — Investigated and resolved complex multiplayer, replication, lifecycle, collision, animation, UI, and packaged-build issues using Visual Studio debugging, logging, engine diagnostics, and network testing.
-
Build & Release Engineering — Managed Unreal Engine builds and packaged releases, diagnosed packaging failures and packaged-only crashes, and prepared the project for Steam Early Access.
-
Technical Direction — Responsible for making architectural and technical decisions across the project, determining when to leverage Unreal Engine's built-in systems versus developing custom solutions to meet NULLSPACE: DATA WAR's gameplay and networking requirements.
Unique Main Menu Setup: Level Streaming and Dynamic Backgrounds
The Problem
One of the challenges I encountered when developing the main menu was creating a background that accurately represented the game's multiplayer maps without maintaining separate copies of each environment.
​
My initial approach could have been to duplicate sections of each map and place them into a dedicated menu level. However, with NULLSPACE: DATA WAR being a long-term project where maps are constantly being updated, this would quickly create unnecessary maintenance. Every change made to a gameplay map would also have to be manually recreated in the main menu.
​
Performance was another concern. Loading multiple complete maps at once would consume additional memory and could cause conflicts between each map's directional lighting, post-processing, and other environment-specific systems. I also wanted the menu to showcase the actual maps dynamically rather than relying on static screenshots.
​
The Solution
I designed the main menu as a parent level that dynamically loads the actual gameplay maps as sub-levels. This allows the menu to reference the live versions of each map, so updates are automatically reflected without maintaining duplicate environments.
​
To make the backgrounds more dynamic, I created a collection of Level Sequences for each multiplayer map. Each sequence follows a dedicated camera path through visually interesting areas and common combat locations. Dozens of sequences are distributed across the maps and played in a randomized order to keep the menu from feeling static.
This system is also tied directly into the Host Match menu. When a player selects a map, the corresponding sub-level is loaded, and its sequences begin playing. As they browse different maps, the background changes with their selection.
​
The result is a maintainable, dynamic map-preview system that uses the game's actual multiplayer environments. Map updates automatically carry over to the main menu, while level streaming, lighting management, and randomized camera sequences keep the experience immersive without unnecessarily loading multiple maps at once.
Character Locomotion: Omnidirectional Movement
The Problem
Putting together a dense animation blueprint required a lot of preparation before I could even start building the system. Each animation state needed a complete and consistent set of assets, but the animation packs I purchased often had gaps in directional or contextual variations. An animation might exist for one movement state but not another, or there might be no suitable animation for a specific gameplay interaction. This became especially noticeable when trying to support different combinations of movement, such as crouched, unarmed, and armed movement, while still keeping transitions between each state clean and consistent.
​
The Solution
I went through the available animation assets and organized them around what the animation blueprint actually needed. Rather than forcing the system to work around missing animations, I filled those gaps with custom animations created directly in Unreal Engine. This included making variations that were needed to keep different movement states consistent and making sure the animations worked properly with the rest of the character's movement system.
​
I also created several animations specifically for the Data War game mode, where the player interacts with the Data Container throughout a match. These included animations for picking up and carrying the Data Container, stealing it from an enemy server, and depositing it at my team's server.
​
By taking the time to prepare and fill out the animation library before fully assembling the blueprint, I was able to build a much more complete and consistent system. This gave the animation blueprint the assets it needed to handle both standard character movement and the game's more specialized gameplay interactions without relying on noticeable gaps or mismatched animations.
Matchmaking Menu: Server Browser
The Problem
One of the bigger challenges I ran into was building a server browser that could reliably communicate with Unreal's Online Subsystem without tightly coupling the UI to the multiplayer logic. The browser needed to handle several asynchronous operations, including creating, finding, and joining sessions. On top of that, the widget interface introduced its own challenges with widget creation and initialization. In some cases, a session search would finish before the UI was ready to receive the results, resulting in null widget references and other initialization issues.
​
The Solution
I created a custom Multiplayer Sessions Subsystem to handle all communication with Unreal's Online Subsystem. Rather than having the UI directly interact with Unreal's session APIs, the subsystem manages those operations and exposes custom delegates for events such as creating, finding, and joining sessions.
​
The server browser could then request a session search and simply listen for the appropriate delegate when the operation completed. The returned results were passed to the UI and used to populate individual server entries. I also had to synchronize the asynchronous session callbacks with the widget's lifecycle, ensuring the browser was fully initialized before attempting to display search results.
​
Aside from the Server Browser and all of its functionality, I also created a Quick Match method of getting into a game, which was much simpler, as I only had to filter the Session Search Results by comparing the game mode of the match and then choosing a random match from that filtered list.
Obtaining Authentic Footage in Real Multiplayer Matches for Marketing
The Problem
One of the major challenges I encountered during the second half of development was capturing authentic multiplayer gameplay footage for NULLSPACE: DATA WAR. We needed footage for trailers, promotional material, and marketing, but we did not have a dedicated team of testers consistently available to fill a server.
​
While we could have staged scenes with AI or placeholder players, I wanted our footage to represent genuine multiplayer gameplay. We began organizing public playtests through our Discord community, giving players a chance to test the game, provide feedback, identify bugs, and help us capture real gameplay.
​
This created another challenge: how could I capture cinematic footage of live matches without interfering with the players? Playing alongside them would limit my ability to control the camera and potentially disrupt the gameplay.
​
The Solution
I developed a set of server-side testing and cinematography tools specifically for our public playtests. As the host, I could make my character invisible and enter a dedicated spectator-style camera mode, allowing me to freely move around the map and capture gameplay from otherwise impossible angles.
​
I also created predefined camera positions throughout each level so I could quickly move between reliable cinematic angles as the action moved around the map. Before each playtest, I created a plan outlining the specific footage I wanted to capture. I loosely choreographed scenarios such as firefights, Data Core ambushes, and coordinated flanking attacks, giving me enough control to capture specific shots while still allowing the gameplay to unfold naturally.
​
This turned our public playtests into both a testing environment and a content-production pipeline, allowing the same sessions to generate player feedback, bug reports, authentic gameplay footage, and promotional material without requiring a dedicated testing or cinematography team.
Fine Tuning Hand Placement Across 20+ Weapons
The Problem
Implementing over 20 weapons across 7 different weapon types introduced a wide range of animation and weapon-integration challenges. Differences in weapon dimensions, proportions, lengths, and attachment points frequently caused issues with hand placement, weapon scale, left-hand IK, and visible stretching of the character’s upper and lower arms.
​
These problems were especially noticeable because the same weapon needed to look correct across multiple character animation states, including aiming down sights and firing from the hip. A socket position that looked correct in one stance could appear noticeably misaligned in another.
​
As the number of weapons increased, I needed a solution that was not only capable of fixing individual issues but also of providing a consistent and efficient workflow for integrating new weapons without repeatedly rebuilding or modifying animation logic.
​
The Solution
To accommodate the differences between weapons and animation states, I implemented dedicated weapon sockets for each character stance. Each weapon contains separate socket positions for its aiming and non-aiming states, allowing the character's left hand to maintain a natural grip regardless of the weapon's unique dimensions.
​
I also developed a workflow for rapidly tuning these sockets in real time. By running the game, un-possessing the character, and orbiting the camera around the character, I could inspect the hand-to-weapon alignment from any angle while simultaneously adjusting the socket position in the editor. This provided immediate visual feedback and made it much faster to identify and correct issues with hand placement, weapon alignment, and arm deformation.
​
After working through these issues across the game's weapon library, I developed a strong understanding of where each type of problem originated and how to resolve it quickly. What initially required troubleshooting across many individual weapons became a repeatable process that allowed me to efficiently integrate and polish new weapons while maintaining consistent animation quality.
**Fun Features
Headshot Decapitations
Custom VFX and SFX when causing a headshot kill
Custom Water Tank Draining System
Custom water squirting VFX when the fish tank is shot. The water drains lower and lower until it reaches the lowest bullet hole. The more the number of bullet holes - the faster the water drains. Puddles form where the water collides with the floor.
Ammo and Grenade Pickups
Custom ammo and grenade pickups. Modeled in Blender and textured in Adobe 3D Substance Painter. Albedo, normal, roughness, and emissive maps. Small easter egg: Domension Studios LLC's mission statement written on back label of ammo box.
