Add more abilities in the sample

2026-06-13 00:01:37 -07:00 · 2023-10-05 16:57:43 -04:00
parent e952256b98
commit 25f2e06400
83 changed files with 966 additions and 356 deletions
@@ -9,4 +9,5 @@ InvalidTagCharacters="\"\',"
 NumBitsForContainerSize=6
 NetIndexFirstBitSegment=16
 +GameplayTagList=(Tag="GameplayCue.Ability.Hero1.PuhBack",DevComment="")
+GameplayTagList=(Tag="GameplayCue.Ability.Hero1.Shield",DevComment="")

@@ -0,0 +1,3 @@
+---,1.000000
+MaxStamina,1000.000000
+StaminaRegen,10.000000
@@ -393,7 +393,7 @@ bool UCogEngineWindow_Selection::ComputeBoundingBoxScreenPosition(const APlayerC
 //--------------------------------------------------------------------------------------------------------------------------
 void UCogEngineWindow_Selection::DrawMainMenuWidget(bool Draw, float& Width)
 {
-    const float PickButtonWidth = FCogWindowWidgets::GetFontWidth() * 5;
+    const float PickButtonWidth = FCogWindowWidgets::GetFontWidth() * 6;
    const float SelectionButtonWidth = FCogWindowWidgets::GetFontWidth() * 30;
    const float ResetButtonWidth = FCogWindowWidgets::GetFontWidth() * 2;
    Width = PickButtonWidth + SelectionButtonWidth + ResetButtonWidth;
@@ -454,7 +454,11 @@ FReply SCogImguiWidget::OnMouseMove(const FGeometry& MyGeometry, const FPointerE
 //--------------------------------------------------------------------------------------------------------------------------
 FReply SCogImguiWidget::OnFocusReceived(const FGeometry& MyGeometry, const FFocusEvent& FocusEvent)
 {
-    return Super::OnFocusReceived(MyGeometry, FocusEvent);
+    Super::OnFocusReceived(MyGeometry, FocusEvent);
+
+    FSlateApplication::Get().ResetToDefaultPointerInputSettings();
+
+    return FReply::Handled();
 }

 //--------------------------------------------------------------------------------------------------------------------------
@@ -13,6 +13,7 @@ public class CogSample : ModuleRules
            "CoreUObject", 
            "Engine", 
            "EnhancedInput",
+            "GameplayTasks",
            "GameplayAbilities",
            "GameplayTags",
            "HeadMountedDisplay", 
@@ -0,0 +1,132 @@
+#include "CogSampleAttributeSet_Caster.h"
+
+#include "Net/Core/PushModel/PushModel.h"
+#include "Net/UnrealNetwork.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCogSampleAttributeSet_Caster::UCogSampleAttributeSet_Caster()
+{
+    InitBaseDamage(100.0f);
+    InitCooldownReduction(0.0f);
+    InitAreaRadiusModifier(0.0f);
+    InitMinStamina(-500.0f);
+    InitStamina(1000.0f);
+    InitMaxStamina(1000.0f);
+    InitStaminaRegen(1.0f);
+    InitStaminaCostReduction(0.0f);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::GetLifetimeReplicatedProps(TArray<class FLifetimeProperty>& OutLifetimeProps) const
+{
+    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+
+    FDoRepLifetimeParams Params;
+    Params.bIsPushBased = true;
+    Params.RepNotifyCondition = REPNOTIFY_Always;
+
+    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Caster, BaseDamage, Params);
+    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Caster, CooldownReduction, Params);
+    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Caster, AreaRadiusModifier, Params);
+    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Caster, Stamina, Params);
+    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Caster, MinStamina, Params);
+    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Caster, MaxStamina, Params);
+    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Caster, StaminaRegen, Params);
+    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Caster, StaminaCostReduction, Params);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::OnRep_BaseDamage(const FGameplayAttributeData& PrevBaseDamage)
+{
+    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Caster, BaseDamage, PrevBaseDamage);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::OnRep_CooldownReduction(const FGameplayAttributeData& PrevCooldownReduction)
+{
+    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Caster, CooldownReduction, PrevCooldownReduction);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::OnRep_AreaRadiusModifier(const FGameplayAttributeData& PrevAreaRadiusModifier)
+{
+    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Caster, AreaRadiusModifier, PrevAreaRadiusModifier);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::OnRep_Stamina(const FGameplayAttributeData& PrevStamina)
+{
+    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Caster, Stamina, PrevStamina);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::OnRep_MinStamina(const FGameplayAttributeData& PrevMinStamina)
+{
+    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Caster, MinStamina, PrevMinStamina);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::OnRep_MaxStamina(const FGameplayAttributeData& PrevMaxStamina)
+{
+    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Caster, MaxStamina, PrevMaxStamina);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::OnRep_StaminaRegen(const FGameplayAttributeData& PrevStaminaRegen)
+{
+    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Caster, StaminaRegen, PrevStaminaRegen);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::OnRep_StaminaCostReduction(const FGameplayAttributeData& PrevStaminaCostReduction)
+{
+    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Caster, StaminaCostReduction, PrevStaminaCostReduction);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::PreAttributeBaseChange(const FGameplayAttribute& Attribute, float& NewValue) const
+{
+    Super::PreAttributeBaseChange(Attribute, NewValue);
+
+    if (Attribute == GetStaminaAttribute())
+    {
+        NewValue = FMath::Clamp(NewValue, GetMinStamina(), GetMaxStamina());
+    }
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue)
+{
+    Super::PreAttributeChange(Attribute, NewValue);
+    ClampAttributes(Attribute, NewValue);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::PostAttributeChange(const FGameplayAttribute& Attribute, float OldValue, float NewValue)
+{
+    Super::PostAttributeChange(Attribute, OldValue, NewValue);
+
+    if (Attribute == GetMaxStaminaAttribute())
+    {
+        UCogSampleFunctionLibrary_Gameplay::AdjustAttributeForMaxChange(GetOwningAbilitySystemComponent(), Stamina, OldValue, NewValue, GetStaminaAttribute());
+    }
+    else
+    {
+        ClampAttributes(Attribute, NewValue);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data)
+{
+    Super::PostGameplayEffectExecute(Data);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAttributeSet_Caster::ClampAttributes(const FGameplayAttribute& Attribute, float& NewValue) const
+{
+    if (Attribute == GetStaminaAttribute())
+    {
+        NewValue = FMath::Clamp(NewValue, GetMinStamina(), GetMaxStamina());
+    }
+}
@@ -0,0 +1,86 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "AttributeSet.h"
+#include "AbilitySystemComponent.h"
+#include "CogSampleFunctionLibrary_Gameplay.h"
+#include "CogSampleAttributeSet_Caster.generated.h"
+
+UCLASS()
+class UCogSampleAttributeSet_Caster : public UAttributeSet
+{
+    GENERATED_BODY()
+
+public:
+
+    UCogSampleAttributeSet_Caster();
+
+    UFUNCTION()
+    virtual void OnRep_BaseDamage(const FGameplayAttributeData& PrevBaseDamage);
+
+    UFUNCTION()
+    virtual void OnRep_CooldownReduction(const FGameplayAttributeData& PrevCooldownReduction);
+
+    UFUNCTION()
+    virtual void OnRep_AreaRadiusModifier(const FGameplayAttributeData& PrevAreaRadiusModifier);
+
+    UFUNCTION()
+    virtual void OnRep_Stamina(const FGameplayAttributeData& PrevStamina);
+
+    UFUNCTION()
+    virtual void OnRep_MinStamina(const FGameplayAttributeData& PrevMinStamina);
+
+    UFUNCTION()
+    virtual void OnRep_MaxStamina(const FGameplayAttributeData& PrevMaxStamina);
+
+    UFUNCTION()
+    virtual void OnRep_StaminaRegen(const FGameplayAttributeData& PrevStaminaRegen);
+
+    UFUNCTION()
+    virtual void OnRep_StaminaCostReduction(const FGameplayAttributeData& PrevStaminaCostReduction);
+
+    virtual void GetLifetimeReplicatedProps(TArray<class FLifetimeProperty>& OutLifetimeProps) const override;
+    virtual void PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue) override;
+    virtual void PostAttributeChange(const FGameplayAttribute& Attribute, float OldValue, float NewValue) override;
+    virtual void PreAttributeBaseChange(const FGameplayAttribute& Attribute, float& NewValue) const override;
+    virtual void PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data) override;
+
+private:
+
+    UPROPERTY(BlueprintReadOnly, Category = "Damage", ReplicatedUsing = OnRep_BaseDamage, meta = (AllowPrivateAccess = "true"))
+    FGameplayAttributeData BaseDamage;
+
+    UPROPERTY(BlueprintReadOnly, Category = "Modifier", ReplicatedUsing = OnRep_CooldownReduction, meta = (AllowPrivateAccess = "true"))
+    FGameplayAttributeData CooldownReduction;
+
+    UPROPERTY(BlueprintReadOnly, Category = "Modifier", ReplicatedUsing = OnRep_AreaRadiusModifier, meta = (AllowPrivateAccess = "true"))
+    FGameplayAttributeData AreaRadiusModifier;
+    
+    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_Stamina, meta = (AllowPrivateAccess = "true"))
+    FGameplayAttributeData Stamina;
+
+    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_MinStamina, meta = (AllowPrivateAccess = "true"))
+    FGameplayAttributeData MinStamina;
+
+    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_MaxStamina, meta = (AllowPrivateAccess = "true"))
+    FGameplayAttributeData MaxStamina;
+    
+    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_StaminaRegen, meta = (AllowPrivateAccess = "true"))
+    FGameplayAttributeData StaminaRegen;
+
+    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_StaminaCostReduction, meta = (AllowPrivateAccess = "true"))
+    FGameplayAttributeData StaminaCostReduction;
+
+    void ClampAttributes(const FGameplayAttribute& Attribute, float& NewValue) const;
+
+public:
+    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Caster, BaseDamage);
+    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Caster, CooldownReduction);
+    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Caster, AreaRadiusModifier);
+    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Caster, Stamina);
+    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Caster, StaminaRegen)
+    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Caster, MinStamina);
+    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Caster, MaxStamina);
+    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Caster, StaminaCostReduction);
+};
+
@@ -11,9 +11,6 @@ UCogSampleAttributeSet_Health::UCogSampleAttributeSet_Health()
    InitMaxHealth(1000.0f);
    InitHealth(1000.0f);
    InitHealthRegen(10.0f);
-
-    InitMaxArmor(500.f);
-    InitArmorRegen(0.f);
 }

 //--------------------------------------------------------------------------------------------------------------------------
@@ -34,24 +31,6 @@ void UCogSampleAttributeSet_Health::OnRep_HealthRegen(const FGameplayAttributeDa
    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Health, HealthRegen, PrevHealthRegen);
 }

-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Health::OnRep_Armor(const FGameplayAttributeData& PrevArmor)
-{
-    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Health, Armor, PrevArmor);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Health::OnRep_MaxArmor(const FGameplayAttributeData& PrevMaxArmor)
-{
-    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Health, MaxArmor, PrevMaxArmor);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Health::OnRep_ArmorRegen(const FGameplayAttributeData& PrevArmorRegen)
-{
-    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Health, ArmorRegen, PrevArmorRegen);
-}
-
 //--------------------------------------------------------------------------------------------------------------------------
 void UCogSampleAttributeSet_Health::OnRep_DamageResistance(const FGameplayAttributeData& PrevDamageResistance)
 {
@@ -70,9 +49,6 @@ void UCogSampleAttributeSet_Health::GetLifetimeReplicatedProps(TArray<class FLif
    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Health, Health, Params);
    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Health, MaxHealth, Params);
    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Health, HealthRegen, Params);
-    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Health, Armor, Params);
-    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Health, MaxArmor, Params);
-    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Health, ArmorRegen, Params);
    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Health, DamageResistance, Params);
 }

@@ -99,10 +75,6 @@ void UCogSampleAttributeSet_Health::PostAttributeChange(const FGameplayAttribute
    {
        UCogSampleFunctionLibrary_Gameplay::AdjustAttributeForMaxChange(GetOwningAbilitySystemComponent(), Health, OldValue, NewValue, GetHealthAttribute());
    }
-    else if (Attribute == GetMaxArmorAttribute())
-    {
-        UCogSampleFunctionLibrary_Gameplay::AdjustAttributeForMaxChange(GetOwningAbilitySystemComponent(), Armor, OldValue, NewValue, GetArmorAttribute());
-    }
    else
    {
        ClampAttributes(Attribute, NewValue);
@@ -138,8 +110,4 @@ void UCogSampleAttributeSet_Health::ClampAttributes(const FGameplayAttribute& At
    {
        NewValue = FMath::Clamp(NewValue, 0.0f, GetMaxHealth());
    }
-    else if (Attribute == GetArmorAttribute())
-    {
-        NewValue = FMath::Clamp(NewValue, 0.0f, GetMaxArmor());
-    }
 }
@@ -20,9 +20,6 @@ public:
    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Health, Health);
    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Health, MaxHealth);
    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Health, HealthRegen)
-    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Health, Armor);
-    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Health, MaxArmor);
-    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Health, ArmorRegen)
    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Health, DamageResistance)

    UFUNCTION()
@@ -34,15 +31,6 @@ public:
    UFUNCTION()
    virtual void OnRep_HealthRegen(const FGameplayAttributeData& PrevHealthRegen);

-    UFUNCTION()
-    virtual void OnRep_Armor(const FGameplayAttributeData& PrevArmor);
-    
-    UFUNCTION()
-    virtual void OnRep_MaxArmor(const FGameplayAttributeData& PrevMaxArmor);
-
-    UFUNCTION()
-    virtual void OnRep_ArmorRegen(const FGameplayAttributeData& PrevArmorRegen);
-
    UFUNCTION()
    virtual void OnRep_DamageResistance(const FGameplayAttributeData& PrevDamageResistance);

@@ -63,16 +51,7 @@ private:
    UPROPERTY(BlueprintReadOnly, Category = "Health", ReplicatedUsing = OnRep_HealthRegen, meta = (AllowPrivateAccess = "true"))
    FGameplayAttributeData HealthRegen;

-    UPROPERTY(BlueprintReadOnly, Category = "Armor", ReplicatedUsing = OnRep_Armor, meta = (AllowPrivateAccess = "true"))
-    FGameplayAttributeData Armor;
-
-    UPROPERTY(BlueprintReadOnly, Category = "Armor", ReplicatedUsing = OnRep_MaxArmor, meta = (AllowPrivateAccess = "true"))
-    FGameplayAttributeData MaxArmor;
-
-    UPROPERTY(BlueprintReadOnly, Category = "Armor", ReplicatedUsing = OnRep_ArmorRegen, meta = (AllowPrivateAccess = "true"))
-    FGameplayAttributeData ArmorRegen;
-
-    UPROPERTY(BlueprintReadOnly, Category = "Armor", ReplicatedUsing = OnRep_DamageResistance, meta = (AllowPrivateAccess = "true"))
+    UPROPERTY(BlueprintReadOnly, Category = "Health", ReplicatedUsing = OnRep_DamageResistance, meta = (AllowPrivateAccess = "true"))
    FGameplayAttributeData DamageResistance;

    void ClampAttributes(const FGameplayAttribute& Attribute, float& NewValue) const;
@@ -1,99 +0,0 @@
-#include "CogSampleAttributeSet_Stamina.h"
-
-#include "Net/Core/PushModel/PushModel.h"
-#include "Net/UnrealNetwork.h"
-
-//--------------------------------------------------------------------------------------------------------------------------
-UCogSampleAttributeSet_Stamina::UCogSampleAttributeSet_Stamina()
-{
-    InitMinStamina(-500.0f);
-    InitStamina(1000.0f);
-    InitMaxStamina(1000.0f);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::OnRep_Stamina(const FGameplayAttributeData& PrevStamina)
-{
-    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Stamina, Stamina, PrevStamina);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::OnRep_MinStamina(const FGameplayAttributeData& PrevMinStamina)
-{
-    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Stamina, MinStamina, PrevMinStamina);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::OnRep_MaxStamina(const FGameplayAttributeData& PrevMaxStamina)
-{
-    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Stamina, MaxStamina, PrevMaxStamina);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::OnRep_StaminaRegen(const FGameplayAttributeData& PrevStaminaRegen)
-{
-    GAMEPLAYATTRIBUTE_REPNOTIFY(UCogSampleAttributeSet_Stamina, StaminaRegen, PrevStaminaRegen);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::GetLifetimeReplicatedProps(TArray<class FLifetimeProperty>& OutLifetimeProps) const
-{
-    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
-
-    FDoRepLifetimeParams Params;
-    Params.bIsPushBased = true;
-    Params.RepNotifyCondition = REPNOTIFY_Always;
-    
-    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Stamina, Stamina, Params);
-    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Stamina, MinStamina, Params);
-    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Stamina, MaxStamina, Params);
-    DOREPLIFETIME_WITH_PARAMS_FAST(UCogSampleAttributeSet_Stamina, StaminaRegen, Params);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue)
-{
-    Super::PreAttributeChange(Attribute, NewValue);
-
-    if (Attribute == GetStaminaAttribute())
-    {
-        NewValue = FMath::Clamp(NewValue, GetMinStamina(), GetMaxStamina());
-    }
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::PreAttributeBaseChange(const FGameplayAttribute& Attribute, float& NewValue) const
-{
-    Super::PreAttributeBaseChange(Attribute, NewValue);
-    ClampAttributes(Attribute, NewValue);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::PostAttributeChange(const FGameplayAttribute& Attribute, float OldValue, float NewValue)
-{
-    Super::PostAttributeChange(Attribute, OldValue, NewValue);
-
-    if (Attribute == GetMaxStaminaAttribute())
-    {
-        UCogSampleFunctionLibrary_Gameplay::AdjustAttributeForMaxChange(GetOwningAbilitySystemComponent(), Stamina, OldValue, NewValue, GetStaminaAttribute());
-    }
-    else
-    {
-        ClampAttributes(Attribute, NewValue);
-    }
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data)
-{
-    Super::PostGameplayEffectExecute(Data);
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleAttributeSet_Stamina::ClampAttributes(const FGameplayAttribute& Attribute, float& NewValue) const
-{
-    if (Attribute == GetStaminaAttribute())
-    {
-        NewValue = FMath::Clamp(NewValue, GetMinStamina(), GetMaxStamina());
-    }
-}
@@ -1,59 +0,0 @@
-#pragma once
-
-#include "CoreMinimal.h"
-#include "AttributeSet.h"
-#include "AbilitySystemComponent.h"
-#include "CogSampleFunctionLibrary_Gameplay.h"
-#include "CogSampleAttributeSet_Stamina.generated.h"
-
-UCLASS()
-class UCogSampleAttributeSet_Stamina : public UAttributeSet
-{
-    GENERATED_BODY()
-
-public:
-
-    UCogSampleAttributeSet_Stamina();
-
-    UFUNCTION()
-    virtual void OnRep_Stamina(const FGameplayAttributeData& PrevStamina);		
-
-    UFUNCTION()
-    virtual void OnRep_MinStamina(const FGameplayAttributeData& PrevMinStamina);
-
-    UFUNCTION()
-    virtual void OnRep_MaxStamina(const FGameplayAttributeData& PrevMaxStamina);
-
-    UFUNCTION()
-    virtual void OnRep_StaminaRegen(const FGameplayAttributeData& PrevStaminaRegen);
-
-    virtual void GetLifetimeReplicatedProps(TArray<class FLifetimeProperty>& OutLifetimeProps) const override;
-    virtual void PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue) override;
-    virtual void PostAttributeChange(const FGameplayAttribute& Attribute, float OldValue, float NewValue) override;
-    virtual void PreAttributeBaseChange(const FGameplayAttribute& Attribute, float& NewValue) const override;
-    virtual void PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data) override;
-
-private:
-
-    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_Stamina, meta = (AllowPrivateAccess = "true"))
-    FGameplayAttributeData Stamina;
-
-    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_MinStamina, meta = (AllowPrivateAccess = "true"))
-    FGameplayAttributeData MinStamina;
-
-    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_MaxStamina, meta = (AllowPrivateAccess = "true"))
-    FGameplayAttributeData MaxStamina;
-    
-    UPROPERTY(BlueprintReadOnly, Category = "Stamina", ReplicatedUsing = OnRep_StaminaRegen, meta = (AllowPrivateAccess = "true"))
-    FGameplayAttributeData StaminaRegen;
-
-    void ClampAttributes(const FGameplayAttribute& Attribute, float& NewValue) const;
-
-public:
-    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Stamina, Stamina);
-    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Stamina, StaminaRegen)
-    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Stamina, MinStamina);
-    ATTRIBUTE_ACCESSORS(UCogSampleAttributeSet_Stamina, MaxStamina);
-
-};
-
@@ -6,8 +6,9 @@
 #include "CogSampleAttributeSet_Health.h"
 #include "CogSampleAttributeSet_Misc.h"
 #include "CogSampleCharacterMovementComponent.h"
-#include "CogSampleForcedMove.h"
+#include "CogSampleGameplayAbility.h"
 #include "CogSampleLogCategories.h"
+#include "CogSampleRootMotionParams.h"
 #include "CogSampleTagLibrary.h"
 #include "Components/CapsuleComponent.h"
 #include "Components/InputComponent.h"
@@ -163,12 +164,26 @@ void ACogSampleCharacter::InitializeAbilitySystem()
            AbilitySystem->GiveAbility(Spec);
        }

+        int32 Index = 0;
        for (FActiveAbilityInfo& AbilityInfo : ActiveAbilities)
        {
            const FGameplayAbilitySpec Spec(AbilityInfo.Ability, 1, INDEX_NONE, this);
            FGameplayAbilitySpecHandle Handle = AbilitySystem->GiveAbility(Spec);
            ActiveAbilityHandles.Add(Handle);
+
+            if (FGameplayAbilitySpec* AddedSpec = AbilitySystem->FindAbilitySpecFromHandle(Handle))
+            {
+                if (UCogSampleGameplayAbility* Ab = Cast<UCogSampleGameplayAbility>(AddedSpec->GetPrimaryInstance()))
+                {
+                    Ab->SetSlotTag(FCogSampleTagLibrary::ActiveAbilityCooldownTags[Index]);
+                }
+            }
+
+            Index++;
        }
+
+        UpdateActiveAbilitySlots();
+
        MARK_PROPERTY_DIRTY_FROM_NAME(ACogSampleCharacter, ActiveAbilityHandles, this);
    }

@@ -497,7 +512,7 @@ void ACogSampleCharacter::SetTeamID(int32 Value)
 }

 //--------------------------------------------------------------------------------------------------------------------------
-int32 ACogSampleCharacter::ApplyForcedMove(const FCogSampleForcedMoveParams& Params)
+int32 ACogSampleCharacter::ApplyRootMotion(const FCogSampleRootMotionParams& Params)
 {
    if (HasAuthority() == false)
    {
@@ -518,22 +533,22 @@ int32 ACogSampleCharacter::ApplyForcedMove(const FCogSampleForcedMoveParams& Par
        }
    }

-    Client_ApplyForcedMove(Params);
-    int32 RootMotionSourceID = ApplyForcedMoveInternal(Params);
+    Client_ApplyRootMotion(Params);
+    int32 RootMotionSourceID = ApplyRootMotionShared(Params);
    return RootMotionSourceID;
 }

 //--------------------------------------------------------------------------------------------------------------------------
-void ACogSampleCharacter::Client_ApplyForcedMove_Implementation(const FCogSampleForcedMoveParams& Params)
+void ACogSampleCharacter::Client_ApplyRootMotion_Implementation(const FCogSampleRootMotionParams& Params)
 {
    if (GetWorld()->GetNetMode() == NM_Client)
    {
-        ApplyForcedMoveInternal(Params);
+        ApplyRootMotionShared(Params);
    }
 }

 //--------------------------------------------------------------------------------------------------------------------------
-uint16 ACogSampleCharacter::ApplyForcedMoveInternal(const FCogSampleForcedMoveParams& Params)
+uint16 ACogSampleCharacter::ApplyRootMotionShared(const FCogSampleRootMotionParams& Params)
 {
    UCogSampleCharacterMovementComponent* MovementComponent = Cast<UCogSampleCharacterMovementComponent>(GetMovementComponent());
    if (MovementComponent == nullptr)
@@ -558,4 +573,39 @@ uint16 ACogSampleCharacter::ApplyForcedMoveInternal(const FCogSampleForcedMovePa

    uint16 RootMotionSourceID = MovementComponent->ApplyRootMotionSource(JumpForce);
    return RootMotionSourceID;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void ACogSampleCharacter::OnRep_ActiveAbilityHandles()
+{
+    UpdateActiveAbilitySlots();
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void ACogSampleCharacter::UpdateActiveAbilitySlots()
+{
+    for (int32 i = 0; i < ActiveAbilityHandles.Num(); ++i)
+    {
+        FGameplayAbilitySpecHandle& Handle = ActiveAbilityHandles[i];
+
+        if (FCogSampleTagLibrary::ActiveAbilityCooldownTags.IsValidIndex(i) == false)
+        {
+            return;
+        }
+
+        FGameplayAbilitySpec* Spec = AbilitySystem->FindAbilitySpecFromHandle(Handle);
+        if (Spec == nullptr)
+        {
+            continue;
+        }
+
+        UCogSampleGameplayAbility* AbilityInstance = Cast<UCogSampleGameplayAbility>(Spec->GetPrimaryInstance());
+        if (AbilityInstance == nullptr)
+        {
+            continue;
+        }
+
+        FGameplayTag SlotTag = FCogSampleTagLibrary::ActiveAbilityCooldownTags[i];
+        AbilityInstance->SetSlotTag(SlotTag);
+    }
 }
@@ -22,7 +22,7 @@ class UInputAction;
 class UInputMappingContext;
 class USpringArmComponent;
 struct FActiveGameplayEffect;
-struct FCogSampleForcedMoveParams;
+struct FCogSampleRootMotionParams;
 struct FGameplayEffectSpec;
 struct FOnAttributeChangeData;

@@ -190,10 +190,10 @@ public:
    int32 TeamID = 0;
    
    //----------------------------------------------------------------------------------------------------------------------
-    // Forced Move
+    // Root Motion
    //----------------------------------------------------------------------------------------------------------------------
    UFUNCTION(BlueprintCallable)
-    int32 ApplyForcedMove(const FCogSampleForcedMoveParams& Params);
+    int32 ApplyRootMotion(const FCogSampleRootMotionParams& Params);

 private:

@@ -227,16 +227,21 @@ private:

    void OnScaleAttributeChanged(const FOnAttributeChangeData& Data);

+    void UpdateActiveAbilitySlots();
+
+    UFUNCTION()
+    void OnRep_ActiveAbilityHandles();
+
    //----------------------------------------------------------------------------------------------------------------------
-    // Forced Move
+    // Root Motion 
    //----------------------------------------------------------------------------------------------------------------------
    UFUNCTION(Reliable, Client)
-    void Client_ApplyForcedMove(const FCogSampleForcedMoveParams& Params);
+    void Client_ApplyRootMotion(const FCogSampleRootMotionParams& Params);

-    uint16 ApplyForcedMoveInternal(const FCogSampleForcedMoveParams& Params);
+    uint16 ApplyRootMotionShared(const FCogSampleRootMotionParams& Params);

    //----------------------------------------------------------------------------------------------------------------------
-    UPROPERTY(Replicated, Transient)
+    UPROPERTY(ReplicatedUsing=OnRep_ActiveAbilityHandles, Transient)
    TArray<FGameplayAbilitySpecHandle> ActiveAbilityHandles;
    
    FDelegateHandle GameplayEffectAddedHandle;
@@ -0,0 +1,56 @@
+#include "CogSampleExecCalculation_PoolRegen.h"
+
+#include "AbilitySystemComponent.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCogSampleExecCalculation_PoolRegen::UCogSampleExecCalculation_PoolRegen()
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleExecCalculation_PoolRegen::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams, OUT FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
+{
+    UAbilitySystemComponent* TargetAbilitySystem = ExecutionParams.GetTargetAbilitySystemComponent();
+
+    const FGameplayEffectSpec& Spec = ExecutionParams.GetOwningSpec();
+    FAggregatorEvaluateParameters EvaluationParameters;
+    EvaluationParameters.SourceTags = Spec.CapturedSourceTags.GetAggregatedTags();
+    EvaluationParameters.TargetTags = Spec.CapturedTargetTags.GetAggregatedTags();
+
+    const float Period = ExecutionParams.GetOwningSpec().GetPeriod();
+
+    float RegenRateValue = 0.0f;
+
+    if (TargetAbilitySystem->HasMatchingGameplayTag(DisableRegenTag) == false)
+    {
+        switch (Mode)
+        {
+            case ECogSamplePoolRegenMode::Attribute:
+            {
+                RegenRateValue = TargetAbilitySystem->GetNumericAttribute(RegenRateAttribute);
+            }
+            break;
+
+            case ECogSamplePoolRegenMode::ScalableFloatRate:
+            {
+                RegenRateValue = RegenRate.GetValueAtLevel(Spec.GetLevel());
+            }
+
+            case ECogSamplePoolRegenMode::MaxPoolDuration:
+            {
+                const float MaxAmount = TargetAbilitySystem->GetNumericAttribute(MaxAmountAttribute);
+                const float TotalDurationValue = TotalDuration.GetValueAtLevel(Spec.GetLevel());
+                RegenRateValue = TotalDurationValue > 0 ? (MaxAmount / TotalDurationValue) * Period : 0.0f;
+            }
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    if (RegenRateValue != 0.0f)
+    {
+        OutExecutionOutput.AddOutputModifier(FGameplayModifierEvaluatedData(AmountAttribute, EGameplayModOp::Additive, RegenRateValue));
+    }
+}
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameplayEffectExecutionCalculation.h"
+#include "ScalableFloat.h"
+#include "CogSampleExecCalculation_PoolRegen.generated.h"
+
+UENUM()
+enum class ECogSamplePoolRegenMode : uint8
+{
+    Attribute,
+    MaxPoolDuration,
+    ScalableFloatRate,
+};
+
+UCLASS()
+class UCogSampleExecCalculation_PoolRegen : public UGameplayEffectExecutionCalculation
+{
+    GENERATED_BODY()
+
+public:
+    UCogSampleExecCalculation_PoolRegen();
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly)
+    FGameplayAttribute AmountAttribute;
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly)
+    FGameplayTag DisableRegenTag;
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly)
+    ECogSamplePoolRegenMode Mode = ECogSamplePoolRegenMode::MaxPoolDuration;
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly, meta = (EditConditionHides, EditCondition = "Mode == ECogSamplePoolRegenMode::Attribute"))
+    FGameplayAttribute RegenRateAttribute;
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly, meta = (EditConditionHides, EditCondition = "Mode == ECogSamplePoolRegenMode::ScalableFloatRate"))
+    FScalableFloat RegenRate;
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly, meta = (EditConditionHides, EditCondition = "Mode == ECogSamplePoolRegenMode::MaxPoolDuration"))
+    FGameplayAttribute MaxAmountAttribute;
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly, meta = (EditConditionHides, EditCondition = "Mode == ECogSamplePoolRegenMode::MaxPoolDuration"))
+    FScalableFloat TotalDuration;
+
+    virtual void Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams, OUT FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const override;
+};
@@ -1,7 +1,15 @@
 #include "CogSampleFunctionLibrary_Gameplay.h"

+#include "Abilities/GameplayAbility.h"
 #include "AbilitySystemComponent.h"
+#include "AbilitySystemGlobals.h"
+#include "CogSampleGameplayEffectContext.h"
+#include "Components/CapsuleComponent.h"
+#include "GameFramework/Character.h"
+#include "GameplayCueNotifyTypes.h"
 #include "GameplayEffectTypes.h"
+#include "Particles/ParticleSystemComponent.h"
+#include "ScalableFloat.h"

 //--------------------------------------------------------------------------------------------------------------------------
 void UCogSampleFunctionLibrary_Gameplay::AdjustAttributeForMaxChange(UAbilitySystemComponent* AbilityComponent, FGameplayAttributeData& AffectedAttribute, float OldValue, float NewMaxValue, const FGameplayAttribute& AffectedAttributeProperty)
@@ -21,4 +29,82 @@ void UCogSampleFunctionLibrary_Gameplay::AdjustAttributeForMaxChange(UAbilitySys
    const float NewDelta = (OldValue > 0.f) ? (CurrentValue * NewMaxValue / OldValue) - CurrentValue : NewMaxValue;

    AbilityComponent->ApplyModToAttributeUnsafe(AffectedAttributeProperty, EGameplayModOp::Additive, NewDelta);
-}
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+FVector UCogSampleFunctionLibrary_Gameplay::GetActorBottomLocation(const AActor* Actor)
+{
+    const FVector Location = Actor->GetActorLocation();
+
+    if (const ACharacter* Character = Cast<ACharacter>(Actor))
+    {
+        const UCapsuleComponent* CapsuleComponent = Character->GetCapsuleComponent();
+        const FVector BottomLocation = Location - FVector::UpVector * CapsuleComponent->GetScaledCapsuleHalfHeight();
+        return BottomLocation;
+    }
+
+    return Location;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool UCogSampleFunctionLibrary_Gameplay::FindAbilitySpecHandleFromClass(UAbilitySystemComponent* AbilitySystemComponent, TSubclassOf<UGameplayAbility> AbilityClass, FGameplayAbilitySpecHandle& SpecHandle)
+{
+    if (const FGameplayAbilitySpec* Spec = AbilitySystemComponent->FindAbilitySpecFromClass(AbilityClass))
+    {
+        SpecHandle = Spec->Handle;
+        return true;
+    }
+
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleFunctionLibrary_Gameplay::ApplyAllGameplayEffectContextValues(const FGameplayCueParameters& Parameters, const FGameplayCueNotify_SpawnResult& SpawnResult)
+{
+    TArray<FCogSampleGameplayEffectContextFloatValue> Entries;
+    UCogSampleEffectContextLibrary::EffectContextGetAllFloatValues(Parameters.EffectContext, Entries);
+
+    for (TObjectPtr<UFXSystemComponent> FXSystemComponent : SpawnResult.FxSystemComponents)
+    {
+        if (UFXSystemComponent* FXSystemComponentPtr = FXSystemComponent.Get())
+        {
+            for (const FCogSampleGameplayEffectContextFloatValue& Entry : Entries)
+            {
+                FXSystemComponentPtr->SetFloatParameter(Entry.Name, Entry.Value);
+            }
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleFunctionLibrary_Gameplay::SendMontageEvent(AActor* Actor, FGameplayTag EventTag, FGameplayEventData Payload)
+{
+    if (::IsValid(Actor))
+    {
+        UAbilitySystemComponent* AbilitySystemComponent = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(Actor);
+        if (AbilitySystemComponent != nullptr && IsValidChecked(AbilitySystemComponent))
+        {
+            FScopedPredictionWindow NewScopedWindow(AbilitySystemComponent, true);
+            AbilitySystemComponent->HandleGameplayEvent(EventTag, &Payload);
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+float UCogSampleFunctionLibrary_Gameplay::GetFloatValue(const FScalableFloat& ScalableFloat, int32 Level)
+{
+    return ScalableFloat.GetValueAtLevel(Level);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool UCogSampleFunctionLibrary_Gameplay::GetBoolValue(const FScalableFloat& ScalableFloat, int32 Level)
+{
+    return ScalableFloat.GetValueAtLevel(Level) > 0;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+int32 UCogSampleFunctionLibrary_Gameplay::GetIntValue(const FScalableFloat& ScalableFloat, int32 Level)
+{
+    return (int32)ScalableFloat.GetValueAtLevel(Level);
+}
+
@@ -4,8 +4,12 @@
 #include "CogSampleFunctionLibrary_Gameplay.generated.h"

 class UAbilitySystemComponent;
+class UGameplayAbility;
+struct FGameplayAbilitySpecHandle;
 struct FGameplayAttribute;
 struct FGameplayAttributeData;
+struct FGameplayCueNotify_SpawnResult;
+struct FGameplayCueParameters;

 #define ATTRIBUTE_ACCESSORS(ClassName, PropertyName) \
    GAMEPLAYATTRIBUTE_PROPERTY_GETTER(ClassName, PropertyName) \
@@ -21,4 +25,28 @@ class UCogSampleFunctionLibrary_Gameplay : public UBlueprintFunctionLibrary
 public:

    static void AdjustAttributeForMaxChange(UAbilitySystemComponent* AbilityComponent, FGameplayAttributeData& AffectedAttribute, float OldValue, float NewMaxValue, const FGameplayAttribute& AffectedAttributeProperty);
+
+    UFUNCTION(BlueprintPure)
+    static FVector GetActorBottomLocation(const AActor* Actor);
+
+    UFUNCTION(BlueprintCallable)
+    static bool FindAbilitySpecHandleFromClass(UAbilitySystemComponent* AbilitySystemComponent, TSubclassOf<UGameplayAbility> AbilityClass, FGameplayAbilitySpecHandle& SpecHandle);
+
+    UFUNCTION(BlueprintCallable)
+    static void ApplyAllGameplayEffectContextValues(const FGameplayCueParameters& Parameters, const FGameplayCueNotify_SpawnResult& SpawnResult);
+
+    /* Same as UAbilitySystemBlueprintLibrary::SendGameplayEventToActor but doesn't log an error when the ability system
+    * is not found. When a montage is played in the montage editor the notifications are executed and if a notification
+    * uses SendGameplayEventToActor it will log an error. */
+    UFUNCTION(BlueprintCallable)
+    static void SendMontageEvent(AActor* Actor, FGameplayTag EventTag, FGameplayEventData Payload);
+
+    UFUNCTION(BlueprintPure)
+    static float GetFloatValue(const FScalableFloat& ScalableFloat, int32 Level);
+
+    UFUNCTION(BlueprintPure)
+    static bool GetBoolValue(const FScalableFloat& ScalableFloat, int32 Level);
+
+    UFUNCTION(BlueprintPure)
+    static int32 GetIntValue(const FScalableFloat& ScalableFloat, int32 Level);
 };
@@ -0,0 +1,193 @@
+#include "CogSampleGameplayAbility.h"
+
+#include "CogSampleTagLibrary.h"
+#include "CogSampleGameplayEffectContext.h"
+#include "CogSampleFunctionLibrary_Gameplay.h"
+#include "CogSampleAttributeSet_Caster.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCogSampleGameplayAbility::UCogSampleGameplayAbility()
+{
+    InstancingPolicy = EGameplayAbilityInstancingPolicy::InstancedPerActor;
+    ActivationBlockedTags.AddTag(Tag_Status_Dead);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+float UCogSampleGameplayAbility::GetUnmitigatedCooldownDuration_Implementation() const
+{
+    return Cooldown.GetValueAtLevel(GetAbilityLevel());
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+float UCogSampleGameplayAbility::GetUnmitigatedCost_Implementation() const
+{
+    return Cost.GetValueAtLevel(GetAbilityLevel());
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool UCogSampleGameplayAbility::CheckCooldown(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, OUT FGameplayTagContainer* OptionalRelevantTags /*= nullptr*/) const
+{
+    if (ActorInfo == nullptr)
+    {
+        return false;
+    }
+
+    if (ActorInfo->AbilitySystemComponent->HasMatchingGameplayTag(Tag_Status_NoCooldown))
+    {
+        return true;
+    }
+
+    if (Super::CheckCooldown(Handle, ActorInfo, OptionalRelevantTags))
+    {
+        return true;
+    }
+
+    if (OptionalRelevantTags != nullptr)
+    {
+        OptionalRelevantTags->AddTag(Tag_Ability_Activation_Fail_Cooldown);
+    }
+
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool UCogSampleGameplayAbility::CheckCost(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, OUT FGameplayTagContainer* OptionalRelevantTags /*= nullptr*/) const
+{
+    if (ActorInfo == nullptr)
+    {
+        return false;
+    }
+
+    if (ActorInfo->AbilitySystemComponent->HasMatchingGameplayTag(Tag_Status_NoCost))
+    {
+        return true;
+    }
+
+    UGameplayEffect* CostEffect = GetCostGameplayEffect();
+    if (CostEffect != nullptr)
+    {
+        //-----------------------------------------------------------------------------------
+        // Can always start ability if cost == 0.
+        //-----------------------------------------------------------------------------------
+        if (IsCostGameplayEffectIsZero(CostEffect, GetAbilityLevel(Handle, ActorInfo), MakeEffectContext(Handle, ActorInfo)))
+        {
+            return true;
+        }
+
+        //-----------------------------------------------------------------------------------
+        // Can start ability if it cost stamina and stamina > 0 
+        //-----------------------------------------------------------------------------------
+        if (CostEffect->InheritableGameplayEffectTags.CombinedTags.HasTag(Tag_Effect_Type_Cost_Stamina))
+        {
+            const float Stamina = ActorInfo->AbilitySystemComponent->GetNumericAttribute(UCogSampleAttributeSet_Caster::GetStaminaAttribute());
+            if (Stamina > 0)
+            {
+                return true;
+            }
+        }
+    }
+
+    //-----------------------------------------------------------------------------------
+    // Handle general case
+    //-----------------------------------------------------------------------------------
+    if (Super::CheckCost(Handle, ActorInfo, OptionalRelevantTags))
+    {
+        return true;
+    }
+
+    if (OptionalRelevantTags != nullptr)
+    {
+        OptionalRelevantTags->AddTag(Tag_Ability_Activation_Fail_Cost);
+    }
+
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+const FGameplayTagContainer* UCogSampleGameplayAbility::GetCooldownTags() const
+{
+    FGameplayTagContainer* MutableTags = const_cast<FGameplayTagContainer*>(&CachedCooldownTags);
+    MutableTags->Reset(); 
+    const FGameplayTagContainer* ParentTags = Super::GetCooldownTags();
+    if (ParentTags)
+    {
+        MutableTags->AppendTags(*ParentTags);
+    }
+    MutableTags->AddTag(SlotTag);
+
+    return MutableTags;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleGameplayAbility::ApplyCooldown(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo) const
+{
+    if (GetUnmitigatedCooldownDuration() <= 0.0f)
+    {
+        return;
+    }
+
+    if (UGameplayEffect* CooldownEffect = GetCooldownGameplayEffect())
+    {
+        FGameplayEffectSpecHandle SpecHandle = MakeOutgoingGameplayEffectSpec(CooldownEffect->GetClass(), GetAbilityLevel());
+        SpecHandle.Data.Get()->DynamicGrantedTags.AddTag(SlotTag);
+        ApplyGameplayEffectSpecToOwner(Handle, ActorInfo, ActivationInfo, SpecHandle);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleGameplayAbility::ApplyCost(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo) const
+{
+    if (GetUnmitigatedCost() <= 0.0f)
+    {
+        return;
+    }
+
+    if (UGameplayEffect* CostEffect = GetCostGameplayEffect())
+    {
+        FGameplayEffectSpecHandle SpecHandle = MakeOutgoingGameplayEffectSpec(CostEffect->GetClass(), GetAbilityLevel());
+        ApplyGameplayEffectSpecToOwner(Handle, ActorInfo, ActivationInfo, SpecHandle);
+    }
+}
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool UCogSampleGameplayAbility::IsCostGameplayEffectIsZero(const UGameplayEffect* GameplayEffect, float Level, const FGameplayEffectContextHandle& EffectContext) const
+{
+    FGameplayEffectSpec Spec(GameplayEffect, EffectContext, Level);
+    Spec.CalculateModifierMagnitudes();
+
+    for (int32 ModIdx = 0; ModIdx < Spec.Modifiers.Num(); ++ModIdx)
+    {
+        const FGameplayModifierInfo& ModDef = Spec.Def->Modifiers[ModIdx];
+        const FModifierSpec& ModSpec = Spec.Modifiers[ModIdx];
+        const float CostValue = ModSpec.GetEvaluatedMagnitude();
+
+        //----------------------------------------------------------------------------------------------
+        // The Cost in the Data is positive, but UCogSampleModifierCalculation_Cost negates it.
+        // Therefore a cost less than zero is an actual cost, and a cost of 0 or greater can be ignored
+        //----------------------------------------------------------------------------------------------
+        if (CostValue < 0)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+float UCogSampleGameplayAbility::GetFloatValueAtAbilityLevel(const FScalableFloat& ScalableFloat) const
+{
+    return UCogSampleFunctionLibrary_Gameplay::GetFloatValue(ScalableFloat, GetAbilityLevel());
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool UCogSampleGameplayAbility::GetBoolValueAtAbilityLevel(const FScalableFloat& ScalableFloat) const
+{
+    return UCogSampleFunctionLibrary_Gameplay::GetBoolValue(ScalableFloat, GetAbilityLevel());
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+int32 UCogSampleGameplayAbility::GetIntValueAtAbilityLevel(const FScalableFloat& ScalableFloat) const
+{
+    return UCogSampleFunctionLibrary_Gameplay::GetIntValue(ScalableFloat, GetAbilityLevel());
+}
@@ -0,0 +1,70 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Abilities/GameplayAbility.h"
+#include "CogSampleGameplayAbility.generated.h"
+
+UCLASS()
+class UCogSampleGameplayAbility : public UGameplayAbility
+{
+    GENERATED_BODY()
+
+public:
+
+    UCogSampleGameplayAbility();
+
+    const FGameplayTag& GetSlotTag() const { return SlotTag; }
+
+    void SetSlotTag(FGameplayTag Value) { SlotTag = Value; }
+
+    //----------------------------------------------------------------------------------------------------------------------
+    // Cooldown & Cost
+    //----------------------------------------------------------------------------------------------------------------------
+
+    UFUNCTION(BlueprintNativeEvent, BlueprintPure, Category = Ability)
+    float GetUnmitigatedCooldownDuration() const;
+
+    UFUNCTION(BlueprintNativeEvent, BlueprintPure, Category = Ability)
+    float GetUnmitigatedCost() const;
+
+    virtual const FGameplayTagContainer* GetCooldownTags() const override;
+
+    virtual void ApplyCooldown(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo) const override;
+    
+    virtual bool CheckCooldown(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, OUT FGameplayTagContainer* OptionalRelevantTags = nullptr) const override;
+    
+    virtual bool CheckCost(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, OUT FGameplayTagContainer* OptionalRelevantTags = nullptr) const override;
+    
+    virtual void ApplyCost(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo) const override;
+
+
+    //----------------------------------------------------------------------------------------------------------------------
+    // Scalable Float
+    //----------------------------------------------------------------------------------------------------------------------
+
+    UFUNCTION(BlueprintPure)
+    float GetFloatValueAtAbilityLevel(const FScalableFloat& ScalableFloat) const; 
+
+    UFUNCTION(BlueprintPure)
+    bool GetBoolValueAtAbilityLevel(const FScalableFloat& ScalableFloat) const;
+
+    UFUNCTION(BlueprintPure)
+    int32 GetIntValueAtAbilityLevel(const FScalableFloat& ScalableFloat) const;
+
+private:
+
+    bool IsCostGameplayEffectIsZero(const UGameplayEffect* GameplayEffect, float Level, const FGameplayEffectContextHandle& EffectContext) const;
+
+    UPROPERTY(BlueprintReadOnly, meta = (AllowPrivateAccess = "true"))
+    FGameplayTag SlotTag;
+
+    UPROPERTY(BlueprintReadOnly, EditAnywhere, Category = "Cooldowns", meta = (AllowPrivateAccess = "true"))
+    FScalableFloat Cooldown;
+
+    UPROPERTY(BlueprintReadOnly, EditAnywhere, Category = "Costs", meta = (AllowPrivateAccess = "true"))
+    FScalableFloat Cost;
+
+    UPROPERTY(Transient)
+    FGameplayTagContainer CachedCooldownTags;
+
+};
@@ -1,69 +0,0 @@
-#include "CogSampleGameplayLibrary.h"
-
-#include "Abilities/GameplayAbility.h"
-#include "AbilitySystemComponent.h"
-#include "AbilitySystemGlobals.h"
-#include "CogSampleGameplayEffectContext.h"
-#include "Components/CapsuleComponent.h"
-#include "GameFramework/Character.h"
-#include "GameplayCueNotifyTypes.h"
-#include "Particles/ParticleSystemComponent.h"
-
-//--------------------------------------------------------------------------------------------------------------------------
-FVector UCogSampleGameplayLibrary::GetActorBottomLocation(const AActor* Actor)
-{
-    const FVector Location = Actor->GetActorLocation();
-
-    if (const ACharacter* Character = Cast<ACharacter>(Actor))
-    {
-        const UCapsuleComponent* CapsuleComponent = Character->GetCapsuleComponent();
-        const FVector BottomLocation = Location - FVector::UpVector * CapsuleComponent->GetScaledCapsuleHalfHeight();
-        return BottomLocation;
-    }
-
-    return Location;
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-bool UCogSampleGameplayLibrary::FindAbilitySpecHandleFromClass(UAbilitySystemComponent* AbilitySystemComponent, TSubclassOf<UGameplayAbility> AbilityClass, FGameplayAbilitySpecHandle& SpecHandle)
-{
-    if (const FGameplayAbilitySpec* Spec = AbilitySystemComponent->FindAbilitySpecFromClass(AbilityClass))
-    {
-        SpecHandle = Spec->Handle;
-        return true;
-    }
-
-    return false;
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleGameplayLibrary::ApplyAllGameplayEffectContextValues(const FGameplayCueParameters& Parameters, const FGameplayCueNotify_SpawnResult& SpawnResult)
-{
-    TArray<FCogSampleGameplayEffectContextFloatValue> Entries;
-    UCogSampleEffectContextLibrary::EffectContextGetAllFloatValues(Parameters.EffectContext, Entries);
-
-    for (TObjectPtr<UFXSystemComponent> FXSystemComponent : SpawnResult.FxSystemComponents)
-    {
-        if (UFXSystemComponent* FXSystemComponentPtr = FXSystemComponent.Get())
-        {
-            for (const FCogSampleGameplayEffectContextFloatValue& Entry : Entries)
-            {
-                FXSystemComponentPtr->SetFloatParameter(Entry.Name, Entry.Value);
-            }
-        }
-    }
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void UCogSampleGameplayLibrary::SendMontageEvent(AActor* Actor, FGameplayTag EventTag, FGameplayEventData Payload)
-{
-    if (::IsValid(Actor))
-    {
-        UAbilitySystemComponent* AbilitySystemComponent = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(Actor);
-        if (AbilitySystemComponent != nullptr && IsValidChecked(AbilitySystemComponent))
-        {
-            FScopedPredictionWindow NewScopedWindow(AbilitySystemComponent, true);
-            AbilitySystemComponent->HandleGameplayEvent(EventTag, &Payload);
-        }
-    }
-}
@@ -1,37 +0,0 @@
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Kismet/KismetSystemLibrary.h"
-#include "CogSampleGameplayLibrary.generated.h"
-
-class UAbilitySystemComponent;
-class UGameplayAbility;
-struct FGameplayAbilitySpecHandle;
-struct FGameplayCueParameters;
-struct FGameplayCueNotify_SpawnResult;
-
-//--------------------------------------------------------------------------------------------------------------------------
-UCLASS(meta = (ScriptName = "CogSampleGameplayLibrary"))
-class UCogSampleGameplayLibrary : public UBlueprintFunctionLibrary
-{
-    GENERATED_BODY()
-
-public:
-
-    UFUNCTION(BlueprintPure)
-    static FVector GetActorBottomLocation(const AActor* Actor);
-
-    UFUNCTION(BlueprintCallable)
-    static bool FindAbilitySpecHandleFromClass(UAbilitySystemComponent* AbilitySystemComponent, TSubclassOf<UGameplayAbility> AbilityClass, FGameplayAbilitySpecHandle& SpecHandle);
-
-    UFUNCTION(BlueprintCallable)
-    static void ApplyAllGameplayEffectContextValues(const FGameplayCueParameters& Parameters, const FGameplayCueNotify_SpawnResult& SpawnResult);
-
-    /* Same as UAbilitySystemBlueprintLibrary::SendGameplayEventToActor but doesn't log an error when the ability system
-    * is not found. When a montage is played in the montage editor the notifications are executed and if a notification
-    * uses SendGameplayEventToActor it will log an error. */
-    UFUNCTION(BlueprintCallable)
-    static void SendMontageEvent(AActor* Actor, FGameplayTag EventTag, FGameplayEventData Payload);
-
-};
-
@@ -22,7 +22,7 @@ namespace CogSampleLog
    {
 #if USE_COG
        FCogDebugLogCategoryManager::AddLogCategory(LogCogAlways, "Always", false);
-        FCogDebugLogCategoryManager::AddLogCategory(LogAbilitySystem, "AbilitySystem");
+        FCogDebugLogCategoryManager::AddLogCategory(LogAbilitySystem, "Ability System");
        FCogDebugLogCategoryManager::AddLogCategory(LogGameplayEffects, "Gameplay Effects");
        FCogDebugLogCategoryManager::AddLogCategory(LogCogCollision, "Collision");
        FCogDebugLogCategoryManager::AddLogCategory(LogCogInput, "Input");
@@ -0,0 +1,29 @@
+#include "CogSampleModifierCalculation_Cooldown.h"
+
+#include "CogSampleGameplayAbility.h"
+#include "CogSampleAttributeSet_Caster.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCogSampleModifierCalculation_Cooldown::UCogSampleModifierCalculation_Cooldown()
+{
+    CooldownReductionDef.AttributeToCapture = UCogSampleAttributeSet_Caster::GetCooldownReductionAttribute();
+    CooldownReductionDef.AttributeSource = EGameplayEffectAttributeCaptureSource::Source;
+    CooldownReductionDef.bSnapshot = false;
+
+    RelevantAttributesToCapture.Add(CooldownReductionDef);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+float UCogSampleModifierCalculation_Cooldown::CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& Spec) const
+{
+    FAggregatorEvaluateParameters EvaluationParameters;
+    float CooldownReduction = 0.0f;
+    GetCapturedAttributeMagnitude(CooldownReductionDef, Spec, EvaluationParameters, CooldownReduction);
+
+    const UCogSampleGameplayAbility* Ability = Cast<UCogSampleGameplayAbility>(Spec.GetContext().GetAbilityInstance_NotReplicated());
+
+    const float UnmitigatedCooldown = (Ability != nullptr) ? Ability->GetUnmitigatedCooldownDuration() : 0.0f;
+    const float MitigatedCooldown = UnmitigatedCooldown * FMath::Max(0.0f, 1.0f - CooldownReduction);
+
+    return MitigatedCooldown;
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameplayModMagnitudeCalculation.h"
+#include "GameplayEffectTypes.h"
+#include "CogSampleModifierCalculation_Cooldown.generated.h"
+
+UCLASS(BlueprintType, Blueprintable)
+class UCogSampleModifierCalculation_Cooldown : public UGameplayModMagnitudeCalculation
+{
+    GENERATED_BODY()
+
+public:
+
+    UCogSampleModifierCalculation_Cooldown();
+
+    float CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& Spec) const override;
+
+private:
+
+    FGameplayEffectAttributeCaptureDefinition CooldownReductionDef;
+};
@@ -0,0 +1,40 @@
+#include "CogSampleModifierCalculation_Cost.h"
+
+#include "CogSampleGameplayAbility.h"
+#include "CogSampleAttributeSet_Caster.h"
+#include "CogSampleTagLibrary.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+UCogSampleModifierCalculation_Cost::UCogSampleModifierCalculation_Cost()
+{
+    StaminaCostReductionDef.AttributeToCapture = UCogSampleAttributeSet_Caster::GetStaminaCostReductionAttribute();
+    StaminaCostReductionDef.AttributeSource = EGameplayEffectAttributeCaptureSource::Source;
+    StaminaCostReductionDef.bSnapshot = false;
+
+    RelevantAttributesToCapture.Add(StaminaCostReductionDef);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+float UCogSampleModifierCalculation_Cost::CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& Spec) const
+{
+    const FGameplayTagContainer* SourceTags = Spec.CapturedSourceTags.GetAggregatedTags();
+    FAggregatorEvaluateParameters EvaluationParameters;
+    EvaluationParameters.SourceTags = SourceTags;
+
+    float CostReduction = 0.0f;
+    GetCapturedAttributeMagnitude(StaminaCostReductionDef, Spec, EvaluationParameters, CostReduction);
+
+    const UCogSampleGameplayAbility* Ability = Cast<UCogSampleGameplayAbility>(Spec.GetContext().GetAbilityInstance_NotReplicated());
+    const float UnmitigatedCost = (Ability != nullptr) ? Ability->GetUnmitigatedCost() : 0.0f;
+    float MitigatedCost = UnmitigatedCost * FMath::Max(0.0f, 1.0f - CostReduction);
+
+    if (SourceTags->HasTag(Tag_Effect_Type_Cost_Overtime))
+    {
+        const float Period = Spec.GetPeriod();
+        MitigatedCost *= Period;
+    }
+
+    return -MitigatedCost;
+}
+
+
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameplayModMagnitudeCalculation.h"
+#include "GameplayEffectTypes.h"
+#include "CogSampleModifierCalculation_Cost.generated.h"
+
+UCLASS(BlueprintType, Blueprintable)
+class UCogSampleModifierCalculation_Cost : public UGameplayModMagnitudeCalculation
+{
+    GENERATED_BODY()
+
+public:
+
+    UCogSampleModifierCalculation_Cost();
+
+    float CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& Spec) const override;
+
+private:
+
+    FGameplayEffectAttributeCaptureDefinition StaminaCostReductionDef;
+};
@@ -2,13 +2,13 @@

 #include "CoreMinimal.h"
 #include "GameFramework/RootMotionSource.h"
-#include "CogSampleForcedMove.generated.h"
+#include "CogSampleRootMotionParams.generated.h"

 class UGameplayEffect;

 //--------------------------------------------------------------------------------------------------------------------------
 USTRUCT(BlueprintType)
-struct FCogSampleForcedMoveParams
+struct FCogSampleRootMotionParams
 {
    GENERATED_BODY()

@@ -27,7 +27,7 @@ public:
    FRotator Rotation;

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
-    bool IsAdditive = true;
+    bool IsAdditive = false;

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 Priority = 0;
@@ -1,15 +1,42 @@
 #include "CogSampleTagLibrary.h"

+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Activation_Fail_Cooldown, "Ability.Activation.Fail.Cooldown");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Activation_Fail_Cost, "Ability.Activation.Fail.Cost");
+
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Cooldown_1, "Ability.Cooldown.1");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Cooldown_2, "Ability.Cooldown.2");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Cooldown_3, "Ability.Cooldown.3");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Cooldown_4, "Ability.Cooldown.4");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Cooldown_5, "Ability.Cooldown.5");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Cooldown_6, "Ability.Cooldown.6");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Cooldown_7, "Ability.Cooldown.7");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Ability_Cooldown_8, "Ability.Cooldown.8");
+
 UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Alignment_Negative, "Effect.Alignment.Negative");
 UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Alignment_Positive, "Effect.Alignment.Positive");

 UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Data_Amount, "Effect.Data.Amount");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Data_Cooldown, "Effect.Data.Cooldown");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Data_Cost, "Effect.Data.Cost");
 UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Data_Damage, "Effect.Data.Damage");
 UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Data_Heal, "Effect.Data.Heal");

 UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Type_Damage_Kill, "Effect.Type.Damage.Kill");
 UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Type_Heal_Full, "Effect.Type.Heal.Full");
 UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Type_Heal_Revive, "Effect.Type.Heal.Revive");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Type_Cost_Free, "Effect.Type.Cost.Free");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Type_Cost_Overtime, "Effect.Type.Cost.Overtime");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Effect_Type_Cost_Stamina, "Effect.Type.Cost.Stamina");
+
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Dead, "Status.Dead");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Ghost, "Status.Ghost");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Immobilized, "Status.Immobilized");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Immune_Damage, "Status.Immune.Damage");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Revived, "Status.Revived");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Silenced, "Status.Silenced");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_NoCooldown, "Status.NoColdown");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_NoCost, "Status.NoCost");
+UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Stunned, "Status.Stunned");

 UE_DEFINE_GAMEPLAY_TAG(Tag_GameplayEvent_Killed, "GameplayEvent.Killed");
 UE_DEFINE_GAMEPLAY_TAG(Tag_GameplayEvent_Revived, "GameplayEvent.Revived");
@@ -17,13 +44,17 @@ UE_DEFINE_GAMEPLAY_TAG(Tag_GameplayEvent_Revived, "GameplayEvent.Revived");
 UE_DEFINE_GAMEPLAY_TAG(Tag_MontageEvent_Cast_Begin, "MontageEvent.Cast.Begin");
 UE_DEFINE_GAMEPLAY_TAG(Tag_MontageEvent_Cast_End, "MontageEvent.Cast.End");

-UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Dead, "Effect.Status.Dead");
-UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Ghost, "Effect.Status.Ghost");
-UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Immobilized, "Effect.Status.Immobilized");
-UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Immune_Damage, "Effect.Status.Immune.Damage");
-UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Revived, "Effect.Status.Revived");
-UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Silenced, "Effect.Status.Silenced");
-UE_DEFINE_GAMEPLAY_TAG(Tag_Status_Stunned, "Effect.Status.Stunned");
-
 UE_DEFINE_GAMEPLAY_TAG(Tag_Unit_Hero, "Unit.Hero");
 UE_DEFINE_GAMEPLAY_TAG(Tag_Unit_Creature, "Unit.Creature");
+
+TArray<FGameplayTag> FCogSampleTagLibrary::ActiveAbilityCooldownTags =
+{ 
+    Tag_Ability_Cooldown_1, 
+    Tag_Ability_Cooldown_2, 
+    Tag_Ability_Cooldown_3, 
+    Tag_Ability_Cooldown_4, 
+    Tag_Ability_Cooldown_5,
+    Tag_Ability_Cooldown_6,
+    Tag_Ability_Cooldown_7,
+    Tag_Ability_Cooldown_8,
+};
@@ -3,16 +3,42 @@
 #include "CoreMinimal.h"
 #include "NativeGameplayTags.h"

+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Activation_Fail_Cooldown);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Activation_Fail_Cost);
+
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Cooldown_1);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Cooldown_2);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Cooldown_3);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Cooldown_4);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Cooldown_5);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Cooldown_6);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Cooldown_7);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Ability_Cooldown_8);
+
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Alignment_Negative);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Alignment_Positive);

 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Data_Amount);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Data_Cooldown);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Data_Cost);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Data_Damage);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Data_Heal);

 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Type_Damage_Kill);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Type_Heal_Full);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Type_Heal_Revive);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Type_Cost_Overtime);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Effect_Type_Cost_Stamina);
+
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Dead);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Ghost);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Immobilized);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Immune_Damage);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_NoCooldown);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_NoCost);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Revived);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Silenced);
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Stunned);

 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_GameplayEvent_Killed);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_GameplayEvent_Revived);
@@ -20,16 +46,12 @@ UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_GameplayEvent_Revived);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_MontageEvent_Cast_Begin);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_MontageEvent_Cast_End);

-UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Dead);
-UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Ghost);
-UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Immobilized);
-UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Immune_Damage);
-UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Revived);
-UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Silenced);
-UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Stunned);
-
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Unit_Hero);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Unit_Creature);

+struct FCogSampleTagLibrary
+{
+public:

-
+    static TArray<FGameplayTag> ActiveAbilityCooldownTags;
+};