Stonebreak

Author: Jacob Mitchell
Date: 6/17/26

Working title (Project-SB) The team never reached the art-and-identity phase, so everything you see here runs on placeholder and a majority of marketplace assets. The value is in the systems underneath.

About

A co-op, top-down, server-authoritative action roguelike game built in Unreal Engine 5.0.3 on top of the Gameplay Ability System (GAS). Friends drop into a shared session over Steam, move with WASD, dash on space, and aim abilities at the cursor while they fight off endless, escalating waves of AI enemies — the spawn rate keeps ramping until the team is overrun. The long-term plan was to grow it into a co-op roguelite; development reached a deep, reusable gameplay-and-multiplayer foundation before the project wound down.

---

Status

This is a systems-complete prototype / vertical-slice foundation, not a finished game.

• ✅ Full GAS framework (attributes, abilities, effects, cues, native gameplay tags) — players and AI.
• ✅ Replicated, server-authoritative multiplayer with client-side prediction for responsive ability casts.
• ✅ Steam session create/join via AdvancedSessions, smoothed movement via SmoothSync.
• ✅ GAS-driven enemy AI on Behavior Trees + Blackboard — three enemy archetypes.
• ✅ Designer-facing Blueprint tooling so abilities, effects, and UI can be authored without C++.
• ✅ Performance-minded UI/VFX: object-pooled floating damage numbers, replicated health bars.
• ❌ Combat feel: ~15–20 prototype abilities explored on a single character; never settled on the "right" kit.
• ❌ Content: three enemies, one work-in-progress player character, placeholder/marketplace art.
• ❌ Roguelite loop: the intended meta-progression was never started.
• ❌Active development: May 29 – August 13, 2024 · ~196 commits · UE 5.0.3 · C++ & Blueprints.

---

Gameplay

• Top-down co-op survival. Designed for 2-player co-op (and tested with more), friends join a Steam session and defend together.
• Twin-stick-style control. WASD to move, space to dash, mouse cursor to aim — every ability resolves against the player's exact cursor position.
• Escalating endless waves. Enemies spawn in increasing numbers and frequency until the team is overwhelmed; surviving longer is the score.
• Three enemy archetypes (all that were implemented):
  • Ranged bird — keeps distance and fires at the players.
  • Axe gopher — a grounded melee bruiser.
  • Charging goat — closes the gap with a telegraphed charge attack and can stun on impact.

---

Highlights

The engineering that this project is really about:

• A Gameplay Ability System framework built from scratch. Custom AttributeSets, an AbilitySystemComponent wired through the PlayerState (shared by players and AI), native C++ gameplay tags carried into Engine.ini, and a GameplayEffect-driven buff/debuff system (e.g. Ablaze, Wet, Stun) hooked up to GameplayCues for VFX/SFX.
• Networked abilities with client-side prediction. A reusable "Wait Target Data" pattern captures client-only data (cursor position) on the casting client, ships it to the server, and runs the authoritative logic — while GAS prediction keeps the cast feeling instant. Both clients stay visually in sync even at ~200 ms simulated ping.
• GAS-powered enemy AI on Behavior Trees. A custom C++ AI character + controller initializes its attributes through PossessedBy, shares the exact same ability/attribute stack as the players, and is driven by Behavior Trees + Blackboard for decision-making (chase, charge, ranged attack, react to stun).
• Designer-first Blueprint tooling. Blueprint-exposed GAS base classes, data-driven configs, and C++ events surfaced to Blueprint (e.g. OnHealthChanged) let teammates create and tune abilities, effects, and UI without writing C++ — the workflow was explicitly set up "to enable quick design."
• Steam multiplayer & sessions. Session create/join and matchmaking through the AdvancedSessions / AdvancedSteamSessions plugins, with SmoothSync smoothing replicated movement and server authority on all gameplay-critical events.
• Performance-minded presentation. An object-pooling system recycles floating damage-number actors instead of spawning/destroying per hit, plus replicated health bars / unit frames and a cel-shaded look.

---

Combat & abilities

Combat centers on a single in-progress character whose kit I iterated on heavily — roughly 15–20 abilities were prototyped while searching for a core that felt good before expanding to a full roster. A representative slice of what was built:

Ability	What it does
Dash (space)	Core mobility — repositioning and dodging through waves.
Blood Orb	A predicted, cursor-aimed projectile with VFX and knockback; an early proving ground for the client-prediction pattern.
Returning cone orbs ("Ahri Q")	Fires orbs in a cone that travel out and return; the design idea was for generated orbs to empower the next auto-attack.
Spear Throw	Cursor-aimed thrown projectile — the first ability built on the new GAS layout.
Rolling Ball	A traveling area/displacement ability.
Grapple Tether	A tether/pull traversal ability.
Auto-attacks	Both melee and ranged auto-attacks with object/trace collision.

Supporting combat systems: GameplayEffect-based stun, knockback (both player→enemy and enemy→player), and a buff/debuff layer (Ablaze, Wet) wired to GameplayCues.

---

Networking & client-side prediction

The networking model is server-authoritative with predicted ability execution for responsiveness:

1. Prediction on the casting client. GAS predicts the ability locally so input feels immediate.
2. Client-only data capture. A "Wait Target Data" task grabs data that only the client knows — most importantly the cursor location — and uploads it to the server.
3. Authoritative resolution. The server runs the real gameplay logic with that data, then replicates results. Net-sync logic keeps both players seeing the same thing even under high latency (validated around 200 ms ping).
4. Smoothed movement. SmoothSync interpolates replicated transforms so remote characters move cleanly regardless of jitter.
5. State replication. Health and other vitals live on a replicated PlayerState; death drops the player into a spectator state.

Sessions (host/find/join) run through AdvancedSessions + AdvancedSteamSessions over the Steam Online Subsystem.

---

Enemy AI

Enemies are first-class GAS actors, not bespoke one-offs:

• Custom C++ AI character & controller. The AI shares the player's GAS architecture — its own AttributeSet and an AbilitySystemComponent initialized in PossessedBy on the controller, with the base class's weak ASC pointers redirected to the correct component.
• Behavior Trees + Blackboard drive moment-to-moment decisions (approach, attack, charge, retreat).
• GAS abilities and reactions. Enemies cast through the same ability/effect pipeline as players, so a GameplayEffect-based stun applied to an enemy correctly interrupts it, and the goat's charge is a real ability with knockback.

---

Designer-facing tooling

A core goal was letting non-programmers build content quickly. Toward that end I built:

• Blueprint-exposed GAS base classes — designers subclass them to author new abilities and GameplayEffects entirely in Blueprint.
• Data-driven configuration — tunable attribute/effect/ability settings so balance changes don't require code.
• C++ events surfaced to Blueprint — e.g. an OnHealthChanged event (refactored to be inheritance-friendly) that UI and gameplay BPs bind to.
• Reusable UI/VFX Blueprints — health bars / unit frames and the object-pooled floating damage-number system, ready to drop onto any new actor.

---

Tech

Unreal Engine 5.0.3 · C++ + Blueprints · Gameplay Ability System (GAS) · AdvancedSessions / AdvancedSteamSessions (Steam sessions) · SmoothSync (movement smoothing) · Git LFS (binary Content/ assets) · cel-shaded rendering.

---

Project layout

Project_SB.uproject              UE5 project file (5.0.3)  
Project_SB.png                   Title/splash art  
Config/                          DefaultEngine.ini etc. — includes native C++ gameplay tags  
Content/                         Blueprints, Behavior Trees, GameplayEffects, widgets, VFX, maps (Git LFS)  
Plugins/  
├── AdvancedSessions/            Session create/find/join helpers  
├── AdvancedSteamSessions/       Steam Online Subsystem integration  
└── SmoothSync/                  Replicated-transform smoothing  
Source/  
├── Project_SB.Target.cs         Game build target  
├── Project_SBEditor.Target.cs   Editor build target  
└── Project_SB/  
    ├── Project_SB.Build.cs      Module + dependency setup (GAS, GameplayTasks, OnlineSubsystem…)  
    ├── SBAssetManager.h         Custom asset manager (native gameplay-tag initialization)  
    ├── Public/                  Headers  
    │   ├── AI/                  AI character, AI controller, AI attribute set  
    │   ├── Character/           Base character + GAS plumbing shared by players & AI  
    │   ├── Player/              Player character, WASD/dash input, camera & cursor aiming  
    │   └── Projectile/          Pooled projectiles (orbs, spear, etc.)  
    └── Private/                 Implementations mirroring Public/  

---

Building & running

This is a UE5 C++ project tracked with Git LFS — install and run git lfs install before cloning, or the binary Content/ assets won't come down.

1. Install Unreal Engine 5.0.3 and Visual Studio 2022 (with the Game development with C++ workload).
2. Clone the repo (with Git LFS enabled).
3. Right-click Project_SB.uproject → Generate Visual Studio project files.
4. Open the generated .sln, build the Development Editor target.
5. Open Project_SB.uproject in the editor.
6. For multiplayer testing, run with 2 players under New Editor Window (PIE), or package and launch with Steam running to exercise real sessions.

---

Team & credits

The project was a collaboration:

Contributor	Focus
Jacob Mitchell	Gameplay programming — GAS framework, all abilities, client-side prediction & netcode, enemy AI, Steam sessions, object pooling, and the Blueprint tooling for designers.
Cody (Shuu-37)	Environment / world art (terrain, foliage, materials), UI animation (damage numbers), health-bar visuals, and many more asset drafts.
Zach Wedel	UI — material function library, unit frames, fonts, main menu, UI blockouts.
Ryan (LemurLoL)	Art assets, cel shader, VFX Blueprints, Git LFS setup.

---

Where it was headed

The foundation was deliberately general so the game could grow into a co-op roguelite:

• A finished, fun core ability kit, then a roster of distinct characters built on the same GAS base.
• A roguelite progression loop layered over the endless waves (upgrades, runs, scaling).
• A fuller enemy roster and encounter design beyond the three current archetypes.
• The Stonebreak art identity (logos, UI, inventory) that Cody had begun drafting.

Development stopped after the systems and multiplayer groundwork were in place — which is exactly what this repository documents.