Built for Unreal Engine 5.7.4. Added experimental version.

Author: Pavreally

Plugins/ComponentDynamicAttributes/ComponentDynamicAttributes.uplugin

@@ -0,0 +1,28 @@
+{
+	"FileVersion": 3,
+	"Version": 1,
+	"VersionName": "1.0",
+	"FriendlyName": "Component Dynamic Attributes",
+	"Description": "Unreal Engine 5 Actor component for dynamic attribute management in single-player games.Numeric attributes only — nothing extra!",
+	"Category": "Experimental",
+	"CreatedBy": "Pavel Gornostaev",
+	"CreatedByURL": "https://github.com/Pavreally",
+	"DocsURL": "https://github.com/Pavreally/ComponentDynamicAttributes",
+	"MarketplaceURL": "",
+	"SupportURL": "",
+	"CanContainContent": true,
+	"IsBetaVersion": true,
+	"IsExperimentalVersion": true,
+	"Installed": true,
+	"Modules": [
+		{
+			"Name": "ComponentDynamicAttributes",
+			"Type": "Runtime",
+			"LoadingPhase": "Default",
+			"PlatformAllowList": [
+				"Win64",
+				"Android"
+			]
+		}
+	]
+}

Plugins/ComponentDynamicAttributes/Config/FilterPlugin.ini

@@ -0,0 +1,8 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll

Plugins/ComponentDynamicAttributes/Config/Tags/GameplayTagsCDA.ini

@@ -0,0 +1,12 @@
+[/Script/GameplayTags.GameplayTagsSettings]
+ImportTagsFromConfig=True
+WarnOnInvalidTags=True
+ClearInvalidTags=False
+AllowEditorTagUnloading=True
+AllowGameTagUnloading=True
+FastReplication=True
+
+[/Script/GameplayTags.GameplayTagsList]
+GameplayTagList=(Tag="CDA.Attribute.Health",DevComment="")
+GameplayTagList=(Tag="CDA.Modifier.Buff",DevComment="")
+GameplayTagList=(Tag="CDA.Modifier.Debuff",DevComment="")

Plugins/ComponentDynamicAttributes/Content/B_CDA_ActorDemo.uasset

@@ -0,0 +1,54 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class ComponentDynamicAttributes : ModuleRules
+{
+	public ComponentDynamicAttributes(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicIncludePaths.AddRange(
+			new string[] {
+				// ... add public include paths required here ...
+			}
+			);
+				
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				// ... add other private include paths required here ...
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"CoreUObject",
+				"Engine",
+				"GameplayTags",
+				// ... add other public dependencies that you statically link with here ...
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Slate",
+				"SlateCore",
+				// ... add private dependencies that you statically link with here ...	
+			}
+			);
+		
+		
+		DynamicallyLoadedModuleNames.AddRange(
+			new string[]
+			{
+				// ... add any modules that your module loads dynamically here ...
+			}
+			);
+	}
+}

Plugins/ComponentDynamicAttributes/Resources/Icon128.png

@@ -0,0 +1,29 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "ComponentDynamicAttributes.h"
+#include "GameplayTagsManager.h"
+#include "Misc/Paths.h"
+
+#define LOCTEXT_NAMESPACE "FComponentDynamicAttributesModule"
+
+// Define the log category
+DEFINE_LOG_CATEGORY(LogComponentDynamicAttributes);
+
+void FComponentDynamicAttributesModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+
+	// Adding a path to plugin tags - fixed to use correct plugin directory
+	UGameplayTagsManager::Get().AddTagIniSearchPath(
+		FPaths::ProjectPluginsDir() / TEXT("ComponentDynamicAttributes/Config/Tags"));
+}
+
+void FComponentDynamicAttributesModule::ShutdownModule()
+{
+	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
+	// we call this function before unloading the module.
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FComponentDynamicAttributesModule, ComponentDynamicAttributes)

Plugins/ComponentDynamicAttributes/Source/ComponentDynamicAttributes/ComponentDynamicAttributes.Build.cs

@@ -0,0 +1,23 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "Components/ActorCDA.h"
+#include "ComponentDynamicAttributes.h"
+
+UActorCDA::UActorCDA()
+{
+	PrimaryComponentTick.bCanEverTick = false;
+	bWantsInitializeComponent = true;
+}
+
+void UActorCDA::InitializeComponent()
+{
+	Super::InitializeComponent();
+
+	// Initialize attributes from data assets at the beginning of the game.
+	InitializeAttributes();
+}
+
+void UActorCDA::BeginPlay()
+{
+	Super::BeginPlay();
+}

Plugins/ComponentDynamicAttributes/Source/ComponentDynamicAttributes/Private/ComponentDynamicAttributes.cpp

@@ -0,0 +1,75 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "Components/ActorCDA.h"
+#include "ComponentDynamicAttributes.h"
+
+void UActorCDA::InitializeAttributes()
+{
+	AttributeIndex.Reset();
+	Attributes.Reset();
+	AttributeDefinitions.Reset();
+
+	if (AttributesData.IsEmpty())
+	{
+		return;
+	}
+
+	int32 TotalDefinitions = 0;
+	for (const TObjectPtr<UAttributesDataAssetCDA>& DataAsset : AttributesData)
+	{
+		if (IsValid(DataAsset))
+		{
+			TotalDefinitions += DataAsset->Attributes.Num();
+		}
+	}
+
+	Attributes.Reserve(TotalDefinitions);
+	AttributeDefinitions.Reserve(TotalDefinitions);
+
+	for (const TObjectPtr<UAttributesDataAssetCDA>& DataAsset : AttributesData)
+	{
+		if (!IsValid(DataAsset))
+		{
+			UE_LOG(LogComponentDynamicAttributes, Warning, TEXT("ActorCDA::InitializeAttributes - Invalid AttributesDataAsset."));
+			continue;
+		}
+
+		if (DataAsset->Attributes.IsEmpty())
+		{
+			continue;
+		}
+
+		for (const FAttributeDefinitionCDA& Definition : DataAsset->Attributes)
+		{
+			AddAttributeDefinition(Definition);
+		}
+	}
+}
+
+void UActorCDA::AddAttributeDefinition(const FAttributeDefinitionCDA& Definition)
+{
+	if (!Definition.AttributeTag.IsValid())
+	{
+		UE_LOG(LogComponentDynamicAttributes, Warning, TEXT("ActorCDA::AddAttributeDefinition - Invalid GameplayTag."));
+		return;
+	}
+
+	if (AttributeIndex.Contains(Definition.AttributeTag))
+	{
+		UE_LOG(LogComponentDynamicAttributes, Warning, TEXT("ActorCDA::AddAttributeDefinition - Duplicate GameplayTag found: %s. Skipping."), *Definition.AttributeTag.ToString());
+		return;
+	}
+
+	const int32 NewIndex = Attributes.AddDefaulted();
+	AttributeIndex.Add(Definition.AttributeTag, NewIndex);
+	AttributeDefinitions.Add(Definition);
+
+	FAttributeRuntimeDataCDA& RuntimeData = Attributes[NewIndex];
+	RuntimeData.BaseValue = Definition.BaseValue;
+	RuntimeData.MinValue = Definition.MinValue;
+	RuntimeData.MaxValue = Definition.MaxValue;
+	RuntimeData.CachedMaxValue = FMath::Clamp(Definition.BaseValue, Definition.MinValue, Definition.MaxValue);
+	RuntimeData.CurrentValue = RuntimeData.CachedMaxValue;
+	RuntimeData.Modifiers.Reset();
+	RuntimeData.bNeedsRecalculation = false;
+}

Plugins/ComponentDynamicAttributes/Source/ComponentDynamicAttributes/Private/Components/ActorCDA.cpp

@@ -0,0 +1,135 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "Components/ActorCDA.h"
+#include "ComponentDynamicAttributes.h"
+
+bool UActorCDA::TryGetAttributeIndex(FGameplayTag Tag, int32& OutIndex) const
+{
+	if (!Tag.IsValid())
+	{
+		UE_LOG(LogComponentDynamicAttributes, VeryVerbose, TEXT("ActorCDA::TryGetAttributeIndex - Invalid GameplayTag: %s"), *Tag.ToString());
+		return false;
+	}
+
+	const int32* FoundIndex = AttributeIndex.Find(Tag);
+	if (!FoundIndex)
+	{
+		UE_LOG(LogComponentDynamicAttributes, VeryVerbose, TEXT("ActorCDA::TryGetAttributeIndex - GameplayTag not found: %s"), *Tag.ToString());
+		return false;
+	}
+
+	if (!Attributes.IsValidIndex(*FoundIndex))
+	{
+		UE_LOG(LogComponentDynamicAttributes, VeryVerbose, TEXT("ActorCDA::TryGetAttributeIndex - Invalid index for tag: %s"), *Tag.ToString());
+		return false;
+	}
+
+	OutIndex = *FoundIndex;
+	return true;
+}
+
+const FAttributeDefinitionCDA* UActorCDA::GetAttributeDefinition(FGameplayTag Tag) const
+{
+	const int32* FoundIndex = AttributeIndex.Find(Tag);
+	if (!FoundIndex)
+	{
+		return nullptr;
+	}
+
+	if (!AttributeDefinitions.IsValidIndex(*FoundIndex))
+	{
+		return nullptr;
+	}
+
+	return &AttributeDefinitions[*FoundIndex];
+}
+
+void UActorCDA::RecalculateAttributeIfNeeded(FGameplayTag Tag, int32 Index)
+{
+	if (!Attributes.IsValidIndex(Index))
+	{
+		return;
+	}
+
+	FAttributeRuntimeDataCDA& Data = Attributes[Index];
+	if (!Data.bNeedsRecalculation)
+	{
+		return;
+	}
+
+	const float OldValue = Data.CurrentValue;
+
+	float AddSum = 0.0f;
+	float MultiplyProduct = 1.0f;
+	bool bHasOverride = false;
+	float OverrideValue = 0.0f;
+
+	for (const FAttributeModifierCDA& Modifier : Data.Modifiers)
+	{
+		switch (Modifier.Type)
+		{
+		case EAttributeModifierTypeCDA::Add:
+			AddSum += Modifier.Value;
+			break;
+		case EAttributeModifierTypeCDA::Multiply:
+			MultiplyProduct *= Modifier.Value;
+			break;
+		case EAttributeModifierTypeCDA::Override:
+			bHasOverride = true;
+			OverrideValue = Modifier.Value;
+			break;
+		default:
+			break;
+		}
+	}
+
+	float FinalValue = (Data.BaseValue + AddSum) * MultiplyProduct;
+	if (bHasOverride)
+	{
+		FinalValue = OverrideValue;
+	}
+
+	const float NewMax = FMath::Clamp(FinalValue, Data.MinValue, Data.MaxValue);
+	Data.CachedMaxValue = NewMax;
+	Data.CurrentValue = FMath::Clamp(Data.CurrentValue, Data.MinValue, Data.CachedMaxValue);
+	Data.bNeedsRecalculation = false;
+
+	BroadcastIfValueChanged(Tag, OldValue, Data.CurrentValue);
+}
+
+void UActorCDA::ApplyOperation(float& TargetValue, EAttributeOperationCDA Operation, float Value) const
+{
+	switch (Operation)
+	{
+	case EAttributeOperationCDA::Add:
+		TargetValue += Value;
+		break;
+	case EAttributeOperationCDA::Subtract:
+		TargetValue -= Value;
+		break;
+	case EAttributeOperationCDA::Multiply:
+		TargetValue *= Value;
+		break;
+	case EAttributeOperationCDA::Divide:
+		if (FMath::IsNearlyZero(Value))
+		{
+			UE_LOG(LogComponentDynamicAttributes, Warning, TEXT("ActorCDA::ApplyOperation - Divide by zero."));
+			return;
+		}
+		TargetValue /= Value;
+		break;
+	case EAttributeOperationCDA::Set:
+		TargetValue = Value;
+		break;
+	default:
+		break;
+	}
+}
+
+void UActorCDA::BroadcastIfValueChanged(FGameplayTag Tag, float OldValue, float NewValue)
+{
+	if (!FMath::IsNearlyEqual(OldValue, NewValue))
+	{
+		OnAttributeChangedCDA.Broadcast(Tag, OldValue, NewValue);
+	}
+}