Back to Projects
Forgotten Requiem

Forgotten Requiem

November 20, 2025 • View on Steam
C++ GAS FlowGraph AI Systems Blueprints UI Editor Tooling

Forgotten Requiem is a singleplayer Diablo-like Action RPG (ARPG) built in Unreal Engine using C++ and the Gameplay Ability System (GAS).

👉 Wishlist “Forgotten Requiem” on Steam (Coming Soon)

🛠️ Key Technical Architecture & Systems

1. FlowGraph Quest & Cinematic Dialogue

  • 25+ custom C++ Flow Nodes (dialogue, dialogue choice, cutscene, save game, spawn/alter enemies, apply gameplay effects, convert NPC to ally, etc.) drive a non-linear quest/dialogue graph that maps progress to GAS gameplay tags and player state, with a data-asset-driven camera preset/focus/shot system giving each dialogue node its own cinematic framing.

2. GAS Damage & Debuff Pipeline

  • A central UGameplayEffectExecutionCalculation (UCpp_ExecCalc_Damage) resolves Physical/Fire/Lightning/Arcane damage against per-type resistance attributes, applies radial falloff damage from an origin/inner/outer radius, and rolls elemental debuffs (Burn, Shock, Stun, Curse) plus several boss-unique status effects (Pandemonium, Pyre of False Comfort, Djinn’s Conduction Armor, Neural Dazzle) off a damage-type-to-debuff gameplay tag map.

3. Data-Driven Boss AI

  • A custom UBTTask_BlueprintBase task (UCpp_BTTask_BossBehaviorTask) turns boss combat into an author-defined state table: each combat state (melee/ranged combos, special attacks, stun, dodge, phase transform) lists distance-based conditions (in-range/closer-than/farther-than, or a Blueprint-custom predicate) that pick the next state — reshaping an entire boss fight is a data edit, not a C++ or Behavior Tree graph change.

4. Spatial (Ambient) Dialogue System

  • A data-driven system, independent of the main quest dialogue, where NPCs pick weighted in-world lines governed by a playback policy (repeatable / once-per-activation / once-per-combat / once-per-save with save-tagged persistence, priority interruption, anti-immediate-repeat).
  • A polymorphic USTRUCT-based trigger library (health-below-threshold with rearm, nearby-hostile-count with rearm, damaged-by-player, ability-used, ally-defeated, timed interval, gameplay event) covers combat and exploration contexts separately, so reactive barks need no manual per-encounter scripting.

5. Engine-Replacement Gameplay Subsystems

  • Shared Timeline Subsystem: A tickable world subsystem replacing per-actor UTimelineComponent usage with pooled, curve-driven timeline tasks (duration/ratio/loop/reverse modes) exposed to both C++ TFunction callbacks and Blueprint delegates.
  • Camera Subsystem: Composes independent base/offset values (mirroring GAS’s base/current attribute pattern) for zoom, pitch, and FOV on top of a third-party cine-camera plugin, each interpolating on its own timer.
  • Actor Pool Subsystem: Generic object pool for projectile/VFX actors that spreads pooled-actor destruction across frames to avoid a spike.
  • Ally Subsystem: Respawns fallen companions off-screen using async line-of-sight traces and navigation reachability queries, with separate in-combat/out-of-combat respawn delays.

6. Automated Test Harness & CI-Style Runner

  • A standalone test plugin (compiled out of Shipping/Test) layers Epic’s Automation Test Framework, CQTest, FunctionalTesting, and AutomationDriver over dedicated test game mode/instance/world fixtures, so every suite runs against disposable fixtures instead of production save slots or levels.
  • Real input, not mocks: a UI test drives the actual spell menu through IAutomationDriverModule’s async driver — moving the cursor to a rendered button’s hit-tested screen position, clicking it, then injecting a raw keyboard press through Slate — and asserts production Enhanced Input bindings activated the ability the UI just equipped.
  • Runtime Flow-graph fixtures: a quest test builds a UFlowAsset graph from scratch via reflection (FindFProperty/ContainerPtrToValuePtr to wire node connections that aren’t exposed to C++), fires 260 kill notifications through it end-to-end, and verifies completion state round-trips through an actual disk save — exercising the exact production Flow nodes, not stubs.
  • Functional-test actors: a checkpoint test spawns a real character and trigger volume and asserts on an actual physics overlap event, not a simulated one, checking save-to-disk and repeated-entry behavior.
  • Headless orchestration: a PowerShell runner launches UnrealEditor -game unattended, tails the live log file by holding a shared read handle while the engine process writes to it, streams pass/fail per test case to the console in real time, and emits HTML/JSON reports plus engine-side raw results — recovering partial results and marking the rest “not run” if the process crashes or times out.

7. Custom Unreal Editor Tooling

  • Interactive Viewport Gizmos: FComponentVisualizer subclasses with custom HComponentVisProxy hit proxies let designers click-and-drag individual patrol points directly in the viewport (HandleInputDelta/GetWidgetLocation), plus a dedicated spawn-radius visualizer for enemy spawners.
  • Blueprint Compiler Extension: A UBlueprintCompilerExtension hooks ProcessBlueprintCompiled to statically flag unsafe ability-delay usage at compile time — static analysis running inside the Blueprint compiler, not just runtime checks.
  • Custom Flow Graph Slate Nodes: Hand-built SGraphNode widgets (SCpp_FlowGraphNode_Dialogue, _DialogueChoice, _StartDialogue) swapped in via custom UFlowGraphNode subclasses so dialogue trees are readable at a glance in the graph editor.
  • Detail Panel Customization: An IDetailCustomization surfaces patrol data on the owning character’s details panel with custom row widgets and a clipboard transfer path that copies a patrol route struct from the component straight onto a Flow node.