Dark Age — Multiplayer Attribute & Inventory Systems (C++ Replication Prototype)

Overview

This project represents my early work learning Unreal Engine C++ multiplayer development, focusing on replicated player attributes and a foundational inventory system. My goal was to understand how Unreal’s networking model works at a low level — server authority, RPCs, replicated properties, and client‑side updates — while building real gameplay systems that function correctly in a multiplayer environment.

This prototype shows the first time I successfully connected C++ gameplay logic with network replication, ensuring that attributes and inventory changes stay consistent across server and clients.

Core Systems Implemented

1. Replicated Attribute System (C++)

I built a lightweight attribute framework in C++ that supports:

  • Health
  • Mana
  • Stamina
  • Any additional stats needed later

Each attribute:

  • Replicates cleanly from server → clients
  • Updates UI on all machines
  • Uses OnRep functions for client‑side reactions
  • Supports clamping, regen, and cost‑based abilities

This was my first deep dive into Unreal’s replication macros, GetLifetimeReplicatedProps, and server‑validated attribute changes.

2. Basic Inventory System (C++ + Replication)

I implemented a simple but functional inventory system that:

  • Stores items in a replicated array
  • Allows adding/removing items on the server
  • Updates correctly on all clients
  • Displays item changes in UI
  • Supports basic item types (resources, consumables, etc.)

This taught me how to structure replicated containers and avoid common pitfalls like:

  • Client‑side desync
  • Duplicate items
  • Incorrect authority flow

3. Server Authority & RPC Flow

This project forced me to learn the correct networking patterns:

  • Client → Server RPCs for actions
  • Server‑side validation
  • Replicated properties for state
  • OnRep callbacks for UI updates

I learned how to avoid “client‑side cheating” by ensuring all gameplay logic runs on the server.

4. Multiplayer Testing & Debugging

I tested the system in a two‑player PIE session to verify:

  • Attribute changes replicate instantly
  • Inventory updates appear on both clients
  • No ghost values or stale UI
  • Server authority is respected

This was my first time debugging multiplayer behavior — and understanding how different it is from single‑player logic.

What I Learned

This project taught me:

  • How Unreal’s networking model actually works
  • How to structure replicated gameplay systems in C++
  • How to use RPCs, RepNotifies, and server authority correctly
  • How to debug multiplayer desync issues
  • How to build systems that scale into a real RPG framework

This was a major step in my transition from “C++ learner” to actual gameplay programmer.

Tools & Technologies

  • Unreal Engine
  • C++ (core gameplay logic)
  • Replication macros & RPCs
  • UPROPERTY replication
  • Basic UI binding
  • Multiplayer PIE testing

Reflection

This prototype wasn’t about visuals — it was about mastering the hardest part of Unreal development: replication. It represents the moment I started thinking like a networked gameplay engineer, not just a single‑player designer.

The systems I built here became the foundation for more advanced multiplayer features I developed later.