Dark Age — C++ Systems Rewrite (First Attempt at Full C++ Gameplay)

Overview

This project represents my first major push to transition Dark Age from Blueprint‑driven gameplay into a fully C++‑based architecture. My goal was to force myself to learn real gameplay development by rebuilding every core system — stats, interaction, harvesting, saving, and world state — directly in C++.

This update shows the earliest working version of that rewrite: a functional survival loop built entirely in code, with no Blueprint logic driving the core systems.

Why This Project Matters

This was the moment I stopped relying on Blueprint convenience and committed to learning actual game development fundamentals:

  • Memory management
  • Class architecture
  • Data structures
  • Tick‑driven systems
  • Actor/component communication
  • Save/load serialization
  • State replication

It was uncomfortable, messy, and challenging — exactly what a real learning milestone looks like.

Core Systems Rebuilt in C++

1. Player Stats System (C++ Only)

From the video, you show:

  • Health
  • Stamina
  • Hunger
  • Thirst

All four bars update in real time, and the logic is fully coded:

  • Hunger & thirst tick down over time
  • When they hit zero, health begins to drain
  • Running drains stamina
  • Jumping drains additional stamina
  • Zero stamina disables running and jumping

This is a complete survival stat loop implemented in C++ .

2. Interaction System

You demonstrate interacting with a door using your new C++ interaction component:

  • Detect interactable actors
  • Trigger interaction events
  • Clean, modular structure

This was your first step toward a reusable interaction framework.

3. Harvesting System

You show a tree being harvested:

  • Tree → stump → logs
  • Logs become pickup items
  • Harvest state is tracked in C++
  • World state persists after saving/loading

This is a foundational gameplay system, and you built it entirely in code.

4. Save/Load System (C++ Serialization)

One of the most impressive parts of the video:

  • Player stats save correctly
  • Player position saves correctly
  • Harvested trees stay harvested after reload

You demonstrate this clearly in the video by:

  • Moving the player
  • Draining stats
  • Saving
  • Reloading
  • Showing everything restored exactly as saved

This is real gameplay programming — not just scripting.

What I Learned

This rewrite taught me:

  • How to structure gameplay systems in C++
  • How to replace Blueprint logic with real code
  • How to manage state across multiple systems
  • How to build modular, reusable components
  • How to serialize world data for saving/loading
  • How to debug C++ crashes and logic errors
  • How to think like a systems programmer

This project marks the moment I started transitioning from designer → developer.

Tools & Technologies

  • Unreal Engine
  • C++ (core gameplay logic)
  • UPROPERTY / UFUNCTION architecture
  • Actor Components
  • SaveGame objects
  • Tick‑based systems
  • Custom interaction and harvesting classes

Reflection

This wasn’t a polished build — it was a breakthrough. It represents the moment I committed to learning C++ the hard way: by rebuilding real systems from scratch.

Every system in this update became the foundation for the more advanced versions I built later. It’s one of the most important steps in my development journey.