Multiplayer FPS Framework - Christopher Wilt

Competitive Shooter Framework — In Active Development

A server-authoritative FPS foundation, written in C++ from the ground up.

Not a template project. Every system here exists because a competitive shooter needs it to be correct under latency: the server owns the truth, the client predicts for feel, and the two are reconciled deliberately. Built solo in Unreal Engine 5 as the groundwork for a Search-and-Destroy style game mode.

Server Authority Client Prediction Lag Compensation Replication EOS Matchmaking Weapon Systems Killcam Replay UMG / HUD Anim Retargeting

Working now: lobbies and matchmaking, buy menu and economy, weapon and recoil systems, movement and slide, compass and minimap, killfeed, killcam replay, match state machine.

In progress: public matchmaking flows, custom game rules, persistent loadouts and settings. The online subsystem files are held back from the public repo while that work is in flux.

NETWORK ARCHITECTURE

The framework is modular by construction: gameplay systems are components and data assets rather than subclasses, so a new weapon, game mode or HUD element is a configuration change instead of an inheritance chain.

Epic Online Services (via EIK) handles peer-to-peer matchmaking, lobby management and authentication. Persistent data lobbies keep a party together on the main menu without an active server IP, and the C++ subsystem binds the Epic social overlay so an accepted invite pulls a player straight into the host's party.

Everything that affects the outcome of a fight is validated server-side. The client is allowed to be optimistic — it traces locally the instant you pull the trigger — but the server re-runs that shot against rewound hitboxes and has the final say.

MODULAR HUD & ECONOMY

I engineered a responsive Buy Menu System using C++ and UMG, which dynamically populates weapon columns based on a WeaponsForSale array. The UI logic includes real-time affordability checks; if a player cannot afford an item, the button is automatically disabled, preventing invalid server requests.

Beyond the economy, the UI utilizes a Master HUD Architecture (UModularPlayerHUD) to control gameplay widgets. This includes a procedural crosshair that dynamically scales based on movement and fire-spread, and a networked minimap that uses a Multicast_PingMinimap RPC to broadcast enemy locations when unsuppressed weapons are fired. The tactical Killfeed was optimized using TWeakObjectPtr and timer handles to gracefully manage message decay and prevent memory leaks.

Again everything in the system is designed to be modular and data-driven, allowing for easy adjustments to the scaling behavior and visual style without modifying core logic. The Minimap, for example, is built to be flexible; the same ping system can be repurposed for tactical equipment like flashbangs or heartbeat sensors by simply changing the icon and parameters in the RPC call, demonstrating the framework's adaptability for future feature expansion. The Mini-Map also shows FOV indicators that dynamically adjust based on the player's current weapon, providing critical situational awareness in combat scenarios or when a you or a team-mate is aiming down sights.

DYNAMIC COMPASS SYSTEM

To provide precise spatial awareness, I engineered a dynamic top-bar compass system. The C++ backend feeds the player's normalized and absolute yaw to the UI, but the UI layer handles the heavy lifting of visual formatting using optimized Blueprint math.

Instead of expensive tick-based conditional branches, the center text calculator uses a highly optimized modulo algorithm. By adding an offset of 22 to the player's yaw, dividing by 45, and applying modulo 8, the 360-degree rotation is instantly converted into an index (0-7) that drives a Select node for the 8 cardinal directions.

The sliding strip markers are generated dynamically. The widget calculates if a specific tick falls on a 45-degree interval using modulo division; if it does, a Widget Switcher swaps the standard degree number for its corresponding cardinal letter, resulting in a clean, modern tactical display.

ADVANCED WEAPON SYSTEM

I architected a data-driven AWeapon class designed for extensibility. The standout feature is the Socket-Driven Procedural ADS System. I completely stripped out hard-coded camera positions and live-tuning in favor of a dynamic offset calculation.

The system checks for active optic attachments; if none exist, it falls back to the base weapon's SightSocket and MuzzleSocket. It then procedurally aligns the weapon to the center of the player's screen over a variable, time-based float (ADS Speed). This ensures perfect optical centering for any modular sight attachment without requiring manual adjustments per weapon.

The inventory relies on a UInventoryComponent that supports a universal weapon slot toggle, enabling modular loadout swapping. Physics-based interactions allow dropped weapons to use randomized "Pop and Spin" torque. Players interact with these items via an optimized proximity trace that calculates a dot-product "look-score". Furthermore, weapon impacts are optimized using a Global Decal Pool capped at 50 instances to strictly preserve rendering budgets.

MOVEMENT & PREDICTION

To achieve "Triple-A" fluidity, I extended the Character Movement Component to support states like Sliding. This dynamically alters ground friction and shrinks the capsule hitbox via a custom ApplySlidePhysics() function. The state is replicated securely, while procedural arm interpolation (FMath::VInterpTo) blends the raw input sway into the first-person mesh to create a responsive combat "glide."

In a competitive shooter, feeling responsive is paramount. I implemented Client-Side Prediction for the firing mechanics. When a player fires, the client immediately calculates the hit trace locally for zero-latency feedback. The Server_FireShot RPC then validates ammo and recalculates the hit using Lag Compensation logic. Animation states are replicated via a compressed integer flag system to minimize packet size while maintaining exact visual fidelity.

SYSTEMS BREAKDOWN

Skeletal Mesh & Retargeting

To support modern AAA mechanics like reciprocating slides and physical magazine drops, the core weapon architecture was upgraded to utilize fully rigged USkeletalMeshComponents. This allows attachments to parent dynamically directly to moving bones via socket tags.

A major technical victory was successfully retargeting the Infima Games Low Poly Weapon Anim Pack from its custom legacy UE4 skeleton to the UE5 Manny skeleton. After auto-alignment failed, I manually set the root retarget bone to the pelvis and meticulously adjusted the clavicle and arm translation settings. This achieved a 98% perfect alignment, bridging legacy assets into a modern UE5 environment.

Modular Recoil Dynamics

I engineered a hybrid, data-driven recoil solver that decouples logic from the weapon class via UDataAssets. It supports immediate hot-swapping between two primary modes: Pattern-Based (Valorant-style deterministic VectorCurve sprays with a custom Stochastic Sway system) and Procedural (CoD-style randomized variance).

This is layered with a procedural Spring-Mass-Damper (SpringInterp) system for independent visual weapon kick and camera roll. The dynamic ADS system calculates the offset between the camera and a "SightSocket" in real-time, procedurally aligning the weapon to the center screen over a time-based float for true modular optics.

Match Flow & State Machine

The core logic was refactored for strict server authority. The server-only ATDMGameMode dictates match phases. The AFPSGameState safely replicates global timers and calculates a WinLossStatusText, driving dynamic HUD elements to show real-time "WINNING/LOSING" status.

During the 15-second PreRound phase, player inputs are intercepted and frozen, allowing players to navigate preset class arrays and push a custom FPlayerLoadout selection to the server. Upon elimination, an asynchronous respawn system un-possesses the pawn, waits for a customizable delay, and securely spawns a fresh character body using the native RestartPlayer routine.

Aaa Killcam Replay

I engineered a server-authorized replay system split into three specialized classes to ensure 1:1 visual parity without memory bloat. The UKillCamRecorderComponent captures compressed FPlayerSnapshot structs (transform, control rotation, weapon class pointer, firing state) every 0.05 seconds, actively trimming data older than 5 seconds.

The local spectator actor (AKillCamGhost) dynamically spawns and destroys weapon classes based on the recorded timeline. To preserve immersion, it forces visibility on 1st-person meshes and hides live actors. Background combatants (AKillCamOtherPlayer) synchronize to a Master Clock, firing collision-safe VFX traces that explicitly ignore live players.

Eos Architecture & Social Overlay

The backend relies on Epic Online Services (EOS) via the EOS Integration Kit. To mimic AAA lobby flows, the framework uses bUseLobbiesIfAvailable to create persistent data lobbies on the main menu, keeping parties together with full Voice Chat support without needing an active server IP.

The C++ subsystem binds directly to the Epic Games Social Overlay (Shift+F3) via OnSessionUserInviteAcceptedDelegate, intercepting accepted invites to seamlessly pull players into the host's party. Additionally, I wrote a custom FSaneEOSLogWriter that actively scrubs sensitive Dev Portal credentials before writing output logs, and utilized ClientReturnToMainMenuWithTextReason to gracefully handle party state edge cases.

WHAT I AM BUILDING NEXT

The framework is continuously evolving. The immediate next phase of development focuses on scaling the Epic Online Services (EOS) backend for public and custom matchmaking, alongside expanding the combat sandbox and the out-of-match user experience.

EOS Matchmaking & Custom Games: Expanding the backend architecture to support seamless Public Matchmaking flows, successfully routing persistent main-menu parties into active UDP server sessions. Engineering a comprehensive Custom Games Setup menu, allowing party hosts to configure map selections and game mode rules, and dynamically injecting these variables into the EOS Session Settings.
Persistent Loadouts & Settings: Developing an out-of-match Custom Loadout Builder and a robust, data-driven Settings System (Audio, Video, Keybinds), utilizing local save architecture (and eventually EOS Player Data Storage) to securely store and retrieve user preferences across sessions.
Advanced Weapon Mechanics: Implementing procedural weapon sway, wall-collision avoidance, and a robust attachment system, alongside tactical and lethal equipment integration.
Locomotion & Expanded Modes: Adding a mantle system and networked spectator states. Engineering a dedicated C++ Bomb class to finalize the Search and Destroy loop, while scaling the match state machine to natively support Free-For-All and Capture the Flag.
UI & Social Expansion: Completing the out-of-match visual experience, polishing the EOS Friends List UI, and refining advanced in-game HUD elements (multi-kill tracking, stance indicators, and stacked damage numbers).