Everything But Titans
Skills
Game Programming
Level Design
Multiplayer Programming
Location
Atlanta
Year
2026
Info
"An exploration of advanced systems architecture for high-mobility combat. By centralizing movement logic within GAS, this project demonstrates how to turn a complex multiplayer prototype into a seamless, fast-paced FPS experience."
Description
"Jetpack" Multiplayer Shooter | Gameplay & Network Programmer
Everything but Titans is a fast-paced, vertical arena shooter prototype inspired by the high-mobility "jetpack" eras of classic FPS titles. Designed from the ground up for both single-player and fully replicated multiplayer, this project served as a deep dive into advanced Unreal Engine frameworks, low-level C++ architecture, and real-world networking.
Technical Architecture & Core Systems
The primary goal of this project was to push the boundaries of Unreal's modern toolset through extensive research and custom engineering, focusing on highly scalable mechanics and robust server-client architecture.
Advanced GAS via Custom C++: Rather than relying on standard Blueprint abilities, I researched and engineered the core Gameplay Ability System (GAS) architecture in C++. By building custom
UGameplayAbilityfunctions and intricate Gameplay Cues, I created a highly scalable framework. This allowed me to push GAS to its limits, turning complex mechanics like omni-directional jetpacks, momentum-based dashes, and more into modular, data-driven assets that could be endlessly combined and iterated upon without bloating the codebase.Steam SDK & Real-World Replication: To move beyond idealized LAN testing, I integrated the Steam SDK (Steamworks) to handle session creation, matchmaking, and live player connections. I conducted extensive research into server-authoritative architecture to ensure fairness in a high-mobility environment. By using GAS’s built-in client-side prediction, I ensured that high-speed aerial combat felt instantly responsive for the client while remaining perfectly synchronized across the Steam network
AI Research: State Trees vs. Behavior Trees: For the enemy bots, I explicitly chose to experiment with Unreal’s newer State Tree system over traditional Behavior Trees. Through my research, I determined that while Behavior Trees are excellent for complex, long-term hierarchical tasks, State Trees provide a much tighter, highly optimized state-machine structure. This made State Trees the superior choice for the fast-paced, reaction-heavy logic of an arena shooter, allowing bots to evaluate transitions between aerial evasion, ground traversal, and combat with minimal performance overhead.
Development Focus: The "Feel" of Combat
Creating a fun "jetpack shooter" requires incredibly tight controls. By centralizing the movement and combat logic within my GAS framework, I was able to rapidly tweak gravity scaling, thrust velocity, and air-strafing parameters. This data-driven approach meant I could iterate on the "feel" of the game in real-time, ensuring the aerial combat felt fluid, momentum-driven, and highly rewarding.
Tech Stack Sidebar
Engine: Unreal Engine 5.6
Core Frameworks: Gameplay Ability System (GAS), State Tree AI
Networking: Steam SDK (Steamworks), Client-Server Replication, RPCs, Client-Side Prediction
Focus: High-Mobility Combat, Multiplayer Architecture
Languages: C++, Blueprints
AI Architecture: State Trees vs. Behavior Trees
For the enemy bots in this project, I explicitly chose to build their logic using Unreal’s newer State Tree system instead of the traditional Behavior Trees I normally use. My goal was to force myself out of my comfort zone and see how this newer framework handled the fast-paced, reaction-heavy AI required for an arena shooter.
The Comparison
Successfully implementing the State Tree system gave me a hands-on perspective of the strengths of both tools:
State Trees (Used in this project): They provide a highly optimized, rigid state-machine structure. I found them incredibly efficient for executing the rapid state transitions needed here (like instantly swapping between "Aerial Evasion" and "Combat").
Behavior Trees: They excel at complex, hierarchical decision-making and offer a highly visual, intuitive workflow.
The Takeaway & Future Approach
While I successfully drove the AI in this prototype using State Trees, and clearly see their massive potential, the experience actually reinforced my appreciation for Behavior Trees.
Because I am already deeply comfortable with the Behavior Tree workflow, I can iterate on gameplay logic and "fun factor" much faster. For the time being, I plan to stick with Behavior Trees as my primary AI framework in upcoming projects to maximize my production speed. However, successfully engineering this project's AI with State Trees gave me a solid foundation, and I will continue studying them so I can confidently leverage both systems as my career progresses.
Technical Insights & Takeaway: The Replication Reality
One of the most defining learning experiences during the development of Everything but Titans wasn't mastering the C++ architecture, but rather untangling the complex realities of multiplayer networking—specifically, the timing discrepancies between the client and the server.
The Challenge: The Latency Gap in High-Mobility
When building a "jetpack" shooter, movement needs to feel instantaneous. Early on, I discovered that the hardest learning curve was not writing the movement logic, but dealing with network latency. The call time differences between a client activating a high-speed dash and the server validating that movement caused noticeable desync and "rubber-banding." High-mobility abilities amplify this timing gap; what felt perfect in a local, zero-ping environment instantly broke down when tested over the Steam network.
The Solution:
Client-Side Prediction via GAS To bridge this gap, I had to deeply understand and leverage the built-in networking capabilities of the Gameplay Ability System (GAS). Instead of waiting for the server's permission to move, I configured GAS to utilize client-side prediction for all traversal abilities. The client executes the jetpack thrust immediately, while simultaneously sending an RPC to the server to validate the action in the background. By fine-tuning how Target Data and state variables were replicated within my C++ classes, I was able to mask those call time differences, resulting in seamless, lag-free aerial combat.
The Takeaway
A Deep Appreciation for Systems Engineering This networking challenge forced me to dive into the absolute depths of GAS, and it turned out to be the most rewarding part of the project. Unpacking how Unreal handles ability replication, attribute scaling, and rollback under the hood was a massive "level up" for me as a systems programmer.
The modularity and raw power of GAS have completely changed how I approach game architecture. I genuinely enjoyed navigating its notoriously steep learning curve, and I am incredibly excited to continue exploring, extending, and pushing the boundaries of what this framework can do in my future projects.
