Written from 12 named sources This foundational package for Chains of the Dragon Throne synthesizes the narrative weight of the Smeef.pdf lore with a high-performance, multiplayer-ready Unreal Engine 5 architecture. Artifact 1 — Game Design Document High Concept Chains of the Dragon Throne is a vertical action RPG where players reclaim a fractured kingdom powered by Smeefs—biological batteries whose essence fuels the world’s ancient machinery. Players navigate the ruined Sky-Reach Kingdom, utilizing both third-person combat and first-person precision to solve puzzles and defeat gatekeeper guardians. Smeef Lore Summary (Anchor: Smeef.pdf) Living Infrastructure: Smeefs are resilient creatures whose bio-energy was once the backbone of the Dragon Throne’s power. The Conflict: Factions are divided: Protectors seek to liberate Smeefs, Harvesters view them as fuel to be spent, and Throne Loyalists believe their exploitation is the only path to restoring order. The Chains: The "Chains" are metaphysical and physical locks on the throne. To "reforge" them, players must collect Smeef Shards and Ancient Links, making every collection a moral choice that echoes through the world's state. Design Pillars Verticality as Gameplay: Levels are designed as "vertical dungeons" where climbing, grappling, and Smeef-powered lifts are primary traversal methods. Collection as Progression: Smeef Shards are not score trinkets; they are required to power the "Gates" that block access to the Throne. Perspective Fluidity: Third-person for agile combat; First-person for mechanical interaction and hidden secret discovery [5][9][15]. Network-First Architecture: Every system is built using the Gameplay Ability System (GAS) and hosted on the PlayerState to ensure Phase 2/3 multiplayer stability [4][7][14]. Core Mechanics Movement: Parkour-inspired traversal utilizing a custom CharacterMovementComponent. Perspective Toggle: A seamless switch between 3rd and 1st person. 1st person is required for "Smeef-Sensing"—detecting hidden energy signatures in the environment [2][12]. Combat: Melee-focused GAS implementation. Abilities (Light Attack, Heavy Attack, Dodge) are data-driven and handle replication/prediction natively [11][14]. AI & Machinery: Smeef-powered devices and enemies utilize StateTree for hierarchical, high-performance logic. Phased Expansion Plan Phase 1 (Single-Player): Core "Throne-Seeker" loop. High-fidelity visuals, vertical slice level, and Smeef collection mechanics. Phase 2 (Co-op Hooks): Introduction of "Echo Players." Shared world state via GameState and persistent progress via GameInstance. Phase 3 (Multiplayer Systems): Full session-based play with server-authoritative combat and synchronized boss encounters. 6-Month Roadmap Month Milestone Key Deliverable 1 Architecture GAS on PlayerState, GameState scaffolding, and Perspective Toggle [4][7]. 2 Vertical Slice First "Sky-Reach" level, Smeef Shard collectibles, and basic gate mechanics. 3 AI & Machinery StateTree implementation for Smeef AI and powered lifts/gates. 4 Combat Systems GAS-based melee, hit reactions, and Chaos Physics-aligned weapon traces. 5 Network Foundation Replicated GameState for shared objectives; Phase 2 co-op join stubs [3][10]. 6 Minimal Playable Full vertical slice with persistence via GameInstance and console parity. Artifact 2 — UE5 C++ / Blueprint Hybrid Prototype Code 2.1 Gameplay Tags (COTDTGameplayTags.h) Centralized tags to avoid "magic strings" and manage state across GAS and UI [11]. #include "NativeGameplayTags.h" UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Character_State_Jumping); UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Character_State_Collecting); UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Character_State_Stunned); UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Camera_FirstPerson); UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Collectible_SmeefShard); 2.2 Collectible Interface (ICollectibleInterface.h) #pragma once #include "CoreMinimal.h" #include "UObject/Interface.h" #include "ICollectibleInterface.generated.h" UINTERFACE(MinimalAPI, Blueprintable) class UCollectibleInterface : public UInterface { GENERATED_BODY() }; class COTDT_API ICollectibleInterface { GENERATED_BODY() public: // Executed on the Collectible itself UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Interaction") void OnCollected(AActor* Collector); }; 2.3 Collectible Base Actor (ACollectibleBase.cpp) Fixes the logic bug: the collectible implements the interface, and the server authorizes the collection. void ACollectibleBase::NotifyActorBeginOverlap(AActor* OtherActor) { if (HasAuthority() && OtherActor->IsA<APawn>()) { if (Implements<UCollectibleInterface>()) { ICollectibleInterface::Execute_OnCollected(this, OtherActor); // Replicated score update logic here... } } } 2.4 Player State & GAS Scaffolding (COTDTPlayerState.h) Phase 2 Ready: ASC on PlayerState ensures attributes survive pawn respawns and are visible to all clients [4][7][14]. UCLASS() class COTDT_API ACOTDTPlayerState : public APlayerState, public IAbilitySystemInterface { GENERATED_BODY() public: ACOTDTPlayerState() { AbilitySystemComponent = CreateDefaultSubobject<UAbilitySystemComponent>(TEXT("ASC")); AbilitySystemComponent->SetIsReplicated(true); AbilitySystemComponent->SetReplicationMode(EGameplayEffectReplicationMode::Mixed); } // Replicated Smeef Count for UI synchronization UPROPERTY(ReplicatedUsing = OnRep_SmeefCount, BlueprintReadOnly, Category = "Stats") int32 SmeefCount; UFUNCTION() void OnRep_SmeefCount() { / Update HUD / } virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override { Super::GetLifetimeReplicatedProps(OutLifetimeProps); DOREPLIFETIME(ACOTDTPlayerState, SmeefCount); } virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override { return AbilitySystemComponent; } protected: UPROPERTY() TObjectPtr<UAbilitySystemComponent> AbilitySystemComponent; }; 2.5 Character & Perspective Toggle (COTDTCharacter.cpp) Uses Enhanced Input and GAS for movement to ensure multiplayer prediction [9][11]. void ACOTDTCharacter::TogglePerspective() { CurrentPerspective = (CurrentPerspective == EPerspectiveState::ThirdPerson) ? EPerspectiveState::FirstPerson : EPerspectiveState::ThirdPerson; // Smooth lerping handled in Blueprint via Timeline/CameraModifier UpdateCameraForPerspective(); } void ACOTDTCharacter::Jump() { // Phase 2 Ready: Movement as Ability if (GetAbilitySystemComponent()) { GetAbilitySystemComponent()->TryActivateAbilityByTag(FGameplayTagContainer(TAG_Character_State_Jumping)); } } 2.6 Persistence Framework ACOTDTGameState: Replicates UnlockedGates (GameplayTagContainer) so all players see the same world state. UCOTDTGameInstance: Stores TotalSmeefs across level loads for the multi-level kingdom transition. Artifact 3 — Core Gameplay Loop Diagram Blueprint Setup Notes Camera Smoothing: In the Character Blueprint, use a Timeline to lerp SpringArm.TargetArmLength (300 to 0) and SpringArm.SocketOffset when the perspective enum changes [15]. Animation Layers: Use Linked Anim Graphs. Create a "FirstPerson_UpperBody" layer that only activates when TAG_Camera_FirstPerson is present on the ASC. StateTree: Use StateTree for environmental puzzles (e.g., a "Smeef-Powered Lift" state machine that checks the SmeefCount on the GameState). Sources [1] Toggle Between Third-Person and First-Person Camera Perspective — https://www.youtube.com/watch?v=fjNLEJ6ai1Q [2] UE5 Camera Toggle System (Third ↔ First Person) — https://www.youtube.com/watch?v=3YDYa0LfLpk [3] Replication for turn-based game, best practices — https://forums.unrealengine.com/t/replication-for-turn-based-game-best-practices/456741 [4] Ability System Component on Character or Player state? — https://www.reddit.com/r/unrealengine/comments/xu2nwv/ability_system_component_on_character_or_player/ [5] How to Switch between Third Person and First Person in Unreal — https://dev.epicgames.com/community/learning/tutorials/Kl4d/how-to-switch-between-third-person-and-first-person-in-unreal-engine-5-in-3-mins [7] Ability System Component for a RPG multiplayer game? — https://forums.unrealengine.com/t/ability-system-component-for-a-rpg-multiplayer-game/1898953 [9] Third Person to First Person Toggle with Enhanced Input — https://www.youtube.com/watch?v=ezJgsyGGC4I [10] Looking for Best Practices and Advise on Replication — https://www.reddit.com/r/unrealengine/comments/1r22ha8/looking_for_best_practices_and_advise_on/ [11] Unreal Engine 5 - The truth of the Gameplay Ability System — https://vorixo.github.io/devtricks/gas/ [12] How to Switch Active Camera - First Person to 3rd Person — https://www.youtube.com/watch?v=MhziE1UZza8 [14] Understanding the Unreal Engine Gameplay Ability System — https://dev.epicgames.com/documentation/en-us/unreal-engine/understanding-the-unreal-engine-gameplay-ability-system [15] How to Switch Between First and Third Person (Smooth Camera) — https://forums.unrealengine.com/t/community-tutorial-how-to-switch-between-first-and-third-person-in-unreal-engine-5-smooth-camera/2528060