Merge branch 'main' into pr/6

Source/CogSample/CogSample.Build.cs

@@ -8,6 +8,7 @@ public class CogSample : ModuleRules
 
 		PublicDependencyModuleNames.AddRange(new string[] 
         { 
+            "AIModule",
             "CogCommon",
             "Core",
             "CoreUObject", 

Source/CogSample/CogSampleAbilitySystemComponent.cpp

@@ -0,0 +1,33 @@
+#include "CogSampleAbilitySystemComponent.h"
+
+#include "AbilitySystemGlobals.h"
+#include "GameplayCueManager.h"
+#include "GameplayEffectTypes.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAbilitySystemComponent::ExecuteGameplayCueLocal(const FGameplayTag GameplayCueTag, const FGameplayCueParameters& GameplayCueParameters) const
+{
+    if (AActor* ActorAvatar = AbilityActorInfo->AvatarActor.Get())
+    {
+        UAbilitySystemGlobals::Get().GetGameplayCueManager()->HandleGameplayCue(ActorAvatar, GameplayCueTag, EGameplayCueEvent::Type::Executed, GameplayCueParameters);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAbilitySystemComponent::AddGameplayCueLocal(const FGameplayTag GameplayCueTag, const FGameplayCueParameters& GameplayCueParameters) const
+{
+    if (AActor* ActorAvatar = AbilityActorInfo->AvatarActor.Get())
+    {
+        UAbilitySystemGlobals::Get().GetGameplayCueManager()->HandleGameplayCue(ActorAvatar, GameplayCueTag, EGameplayCueEvent::Type::OnActive, GameplayCueParameters);
+        UAbilitySystemGlobals::Get().GetGameplayCueManager()->HandleGameplayCue(ActorAvatar, GameplayCueTag, EGameplayCueEvent::Type::WhileActive, GameplayCueParameters);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleAbilitySystemComponent::RemoveGameplayCueLocal(const FGameplayTag GameplayCueTag, const FGameplayCueParameters& GameplayCueParameters) const
+{
+    if (AActor* ActorAvatar = AbilityActorInfo->AvatarActor.Get())
+    {
+        UAbilitySystemGlobals::Get().GetGameplayCueManager()->HandleGameplayCue(ActorAvatar, GameplayCueTag, EGameplayCueEvent::Type::Removed, GameplayCueParameters);
+    }
+}

Source/CogSample/CogSampleAbilitySystemComponent.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "AbilitySystemComponent.h"
+#include "CogSampleAbilitySystemComponent.generated.h"
+
+UCLASS(BlueprintType)
+class UCogSampleAbilitySystemComponent : public UAbilitySystemComponent
+{
+    GENERATED_BODY()
+    
+public:
+    
+    UFUNCTION(BlueprintCallable, Category = "GameplayCue", Meta = (AutoCreateRefTerm = "GameplayCueParameters", GameplayTagFilter = "GameplayCue"))
+    void ExecuteGameplayCueLocal(const FGameplayTag GameplayCueTag, const FGameplayCueParameters& GameplayCueParameters) const;
+
+    UFUNCTION(BlueprintCallable, Category = "GameplayCue", Meta = (AutoCreateRefTerm = "GameplayCueParameters", GameplayTagFilter = "GameplayCue"))
+    void AddGameplayCueLocal(const FGameplayTag GameplayCueTag, const FGameplayCueParameters& GameplayCueParameters) const;
+
+    UFUNCTION(BlueprintCallable, Category = "GameplayCue", Meta = (AutoCreateRefTerm = "GameplayCueParameters", GameplayTagFilter = "GameplayCue"))
+    void RemoveGameplayCueLocal(const FGameplayTag GameplayCueTag, const FGameplayCueParameters& GameplayCueParameters) const;
+
+
+};

Source/CogSample/CogSampleBTTask_BlueprintBase.cpp

@@ -0,0 +1,14 @@
+#include "CogSampleBTTask_BlueprintBase.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+FString UCogSampleBTTask_BlueprintBase::GetStaticDescription() const
+{
+	FString CustomDescripton = GetCustomStaticDescription();
+
+	if (CustomDescripton.IsEmpty() == false)
+	{
+		return CustomDescripton;
+	}
+
+	return Super::GetStaticDescription();
+}

Source/CogSample/CogSampleBTTask_BlueprintBase.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BehaviorTree/Tasks/BTTask_BlueprintBase.h"
+#include "CogSampleBTTask_BlueprintBase.generated.h"
+
+UCLASS(Abstract, Blueprintable)
+class UCogSampleBTTask_BlueprintBase : public UBTTask_BlueprintBase
+{
+    GENERATED_BODY()
+
+public:
+
+	virtual FString GetStaticDescription() const override;
+
+    UFUNCTION(BlueprintImplementableEvent, Category = AI)
+    FString GetCustomStaticDescription() const;
+};

Source/CogSample/CogSampleCharacter.cpp

@@ -2,6 +2,7 @@
 
 #include "Camera/CameraComponent.h"
 #include "CogCommon.h"
+#include "CogSampleAbilitySystemComponent.h"
 #include "CogSampleAttributeSet_Health.h"
 #include "CogSampleAttributeSet_Misc.h"
 #include "CogSampleCharacterMovementComponent.h"
@@ -64,9 +65,9 @@ ACogSampleCharacter::ACogSampleCharacter(const FObjectInitializer& ObjectInitial
 	FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
 	FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm
 
-    AbilitySystem = CreateDefaultSubobject<UAbilitySystemComponent>(TEXT("AbilitySystem"));
+    AbilitySystem = CreateDefaultSubobject<UCogSampleAbilitySystemComponent>(TEXT("AbilitySystem"));
     AbilitySystem->SetIsReplicated(true);
-    AbilitySystem->SetReplicationMode(EGameplayEffectReplicationMode::Mixed);
+    AbilitySystem->SetReplicationMode(EGameplayEffectReplicationMode::Full);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -108,6 +109,7 @@ void ACogSampleCharacter::BeginPlay()
 	}
 
     TryFinishInitialize();
+    RefreshServerAnimTickOption();
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -243,22 +245,31 @@ void ACogSampleCharacter::InitializeAbilitySystem()
             AbilitySystem->GiveAbility(Spec);
         }
 
-        int32 Index = 0;
-        for (FActiveAbilityInfo& AbilityInfo : ActiveAbilities)
+        for (int32 i = 0; i < ActiveAbilities.Num(); ++i)
         {
+            const FActiveAbilityInfo& AbilityInfo = ActiveAbilities[i];
             const FGameplayAbilitySpec Spec(AbilityInfo.Ability, 1, INDEX_NONE, this);
-            FGameplayAbilitySpecHandle Handle = AbilitySystem->GiveAbility(Spec);
+            const FGameplayAbilitySpecHandle Handle = AbilitySystem->GiveAbility(Spec);
             ActiveAbilityHandles.Add(Handle);
 
-            if (FGameplayAbilitySpec* AddedSpec = AbilitySystem->FindAbilitySpecFromHandle(Handle))
+            const FGameplayAbilitySpec* AddedSpec = AbilitySystem->FindAbilitySpecFromHandle(Handle);
+            if (AddedSpec == nullptr)
             {
-                if (UCogSampleGameplayAbility* Ab = Cast<UCogSampleGameplayAbility>(AddedSpec->GetPrimaryInstance()))
-                {
-                    Ab->SetCooldownTag(UCogSampleFunctionLibrary_Tag::ActiveAbilityCooldownTags[Index]);
-                }
+                continue;
             }
 
-            Index++;
+            UCogSampleGameplayAbility* Ability = Cast<UCogSampleGameplayAbility>(AddedSpec->GetPrimaryInstance());
+            if (Ability == nullptr)
+            {
+                continue;
+            }
+            
+            if (UCogSampleFunctionLibrary_Tag::ActiveAbilityCooldownTags.IsValidIndex(i) == false)
+            {
+                continue;
+            }
+            
+            Ability->SetCooldownTag(UCogSampleFunctionLibrary_Tag::ActiveAbilityCooldownTags[i]);
         }
 
         UpdateActiveAbilitySlots();
@@ -639,6 +650,29 @@ void ACogSampleCharacter::OnScaleAttributeChanged(const FOnAttributeChangeData&
 
     MARK_PROPERTY_DIRTY_FROM_NAME(ACogSampleCharacter, Scale, this);
     OnRep_Scale();
+
+    RefreshServerAnimTickOption();
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void ACogSampleCharacter::RefreshServerAnimTickOption()
+{
+    const UCapsuleComponent* Capsule = GetCapsuleComponent();
+    if (Capsule == nullptr)
+    {
+        return;
+    }
+
+    USkeletalMeshComponent* SkeletalMesh = GetMesh();
+    if (SkeletalMesh == nullptr)
+    {
+        return;
+    }
+
+    const float ScaledHalfHeight = Capsule->GetScaledCapsuleHalfHeight();
+    const bool IsBigEnoughToSimulateBonesOnServer = ScaledHalfHeight > 200;
+    SkeletalMesh->VisibilityBasedAnimTickOption = IsBigEnoughToSimulateBonesOnServer ? EVisibilityBasedAnimTickOption::AlwaysTickPoseAndRefreshBones
+                                                                                     : EVisibilityBasedAnimTickOption::OnlyTickMontagesWhenNotRendered;
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -765,3 +799,24 @@ void ACogSampleCharacter::GetTargetCapsules(TArray<const UCapsuleComponent*>& Ca
     Capsules.Add(GetCapsuleComponent());
 }
 
+//--------------------------------------------------------------------------------------------------------------------------
+bool ACogSampleCharacter::GetMontage(FName MontageName, UAnimMontage*& Montage, bool bPrintWarning) const
+{
+    Montage = nullptr;
+
+    if (MontageTable == nullptr)
+    {
+        return false;
+    }
+
+    static FString ContextString(TEXT("GetMontage"));
+    FCogSampleMontageTableRow* Row = MontageTable->FindRow<FCogSampleMontageTableRow>(MontageName, ContextString, bPrintWarning);
+
+    if (Row == nullptr)
+    {
+        return false;
+    }
+
+    Montage = Row->Montage;
+    return Montage != nullptr;
+}

Source/CogSample/CogSampleCharacter.h

@@ -8,6 +8,7 @@
 #include "CogCommonDebugFilteredActorInterface.h"
 #include "CogSampleDamageEvent.h"
 #include "CogSampleDefines.h"
+#include "CogSampleDamageableInterface.h"
 #include "CogSampleTargetableInterface.h"
 #include "CogSampleTeamInterface.h"
 #include "GameFramework/Character.h"
@@ -16,9 +17,9 @@
 #include "InputActionValue.h"
 #include "CogSampleCharacter.generated.h"
 
-class UAbilitySystemComponent;
-class UCogAbilitySystemComponent;
 class UCameraComponent;
+class UCogAbilitySystemComponent;
+class UCogSampleAbilitySystemComponent;
 class UGameplayAbility;
 class UGameplayEffect;
 class UInputAction;
@@ -58,6 +59,19 @@ public:
     bool ActivateWhenGiven = false;
 };
 
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT(BlueprintType)
+struct FCogSampleMontageTableRow : public FTableRowBase
+{
+    GENERATED_BODY()
+
+public:
+    FCogSampleMontageTableRow() {}
+
+    UPROPERTY(EditAnywhere, BlueprintReadOnly)
+    UAnimMontage* Montage = nullptr;
+};
+
 //--------------------------------------------------------------------------------------------------------------------------
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FCogSampleCharacterEventDelegate, ACogSampleCharacter*, Character);
 
@@ -69,6 +83,7 @@ class ACogSampleCharacter : public ACharacter
     , public ICogCommonAllegianceActorInterface
     , public ICogSampleTeamInterface
     , public ICogSampleTargetableInterface
+    , public ICogSampleDamageableInterface
 {
 	GENERATED_BODY()
 
@@ -118,6 +133,14 @@ public:
 
     virtual void GetTargetCapsules(TArray<const UCapsuleComponent*>& Capsules) const override;
 
+    //----------------------------------------------------------------------------------------------------------------------
+    // ICogSampleDamageableInterface overrides
+    //----------------------------------------------------------------------------------------------------------------------
+
+    virtual void HandleDamageReceived(const FCogSampleDamageEventParams& Params) override;
+
+    virtual void HandleDamageDealt(const FCogSampleDamageEventParams& Params) override;
+
     //----------------------------------------------------------------------------------------------------------------------
     // Team
     //----------------------------------------------------------------------------------------------------------------------
@@ -182,16 +205,12 @@ public:
     UFUNCTION(BlueprintPure)
     bool IsInitialized() const { return bIsInitialized; }
 
-    void HandleDamageReceived(const FCogSampleDamageEventParams& Params);
-
-    void HandleDamageDealt(const FCogSampleDamageEventParams& Params);
-
     void OnKilled(AActor* InInstigator, AActor* InCauser, const FGameplayEffectSpec& InEffectSpec, float InMagnitude);
 
     void OnRevived(AActor* InInstigator, AActor* InCauser, const FGameplayEffectSpec& InEffectSpec, float InMagnitude);
 
     UPROPERTY(BlueprintReadOnly, Category = Ability, meta = (AllowPrivateAccess = "true"))
-    UAbilitySystemComponent* AbilitySystem = nullptr;
+    UCogSampleAbilitySystemComponent* AbilitySystem = nullptr;
 
     UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Ability)
     TArray<TSubclassOf<UAttributeSet>> AttributeSets;
@@ -229,10 +248,21 @@ public:
     UFUNCTION(BlueprintCallable)
     int32 ApplyRootMotion(const FCogSampleRootMotionParams& Params);
 
+    //----------------------------------------------------------------------------------------------------------------------
+    // Montage
+    //----------------------------------------------------------------------------------------------------------------------
+    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation", meta = (RowType = "/Script/CogSample.FCogSampleMontageTableRow"))
+    UDataTable* MontageTable = nullptr;
+
+    UFUNCTION(BlueprintCallable, BlueprintPure=false)
+    bool GetMontage(FName MontageName, UAnimMontage*& Montage, bool bPrintWarning) const;
+
 private:
-    
     friend class ACogSamplePlayerController;
 
+    void RefreshServerAnimTickOption();
+
+
     UPROPERTY()
     AController* InitialController = nullptr;
 
@@ -272,8 +302,6 @@ private:
 
     void OnGameplayEffectRemoved(const FActiveGameplayEffect& RemovedGameplayEffect);
 
-    void OnCooldownEffectUpdated(const FActiveGameplayEffect& GameplayEffect, bool bIsEffectRemoved);
-
     void OnGhostTagNewOrRemoved(const FGameplayTag InTag, int32 NewCount);
 
     void OnScaleAttributeChanged(const FOnAttributeChangeData& Data);

Source/CogSample/CogSampleDamageEvent.h

@@ -1,26 +1,3 @@
 #pragma once
 
 #include "CoreMinimal.h"
-#include "CogSampleDamageEvent.generated.h"
-
-//--------------------------------------------------------------------------------------------------------------------------
-USTRUCT(BlueprintType)
-struct FCogSampleDamageEventParams
-{
-    GENERATED_BODY()
-
-public:
-    UPROPERTY(BlueprintReadWrite)
-    float MitigatedDamage = 0;
-    
-    UPROPERTY(BlueprintReadWrite)
-    float UnmitigatedDamage = 0;
-    
-    UPROPERTY(BlueprintReadWrite)
-    AActor* DamageDealer = nullptr;
-    
-    UPROPERTY(BlueprintReadWrite)
-    AActor* DamageReceiver = nullptr;
-};
-
-DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FCogSampleDamageEventDelegate, const FCogSampleDamageEventParams&, Params);

Source/CogSample/CogSampleDamageableInterface.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogSampleDamageableInterface.generated.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+USTRUCT(BlueprintType)
+struct FCogSampleDamageEventParams
+{
+    GENERATED_BODY()
+
+public:
+    UPROPERTY(BlueprintReadWrite)
+    float MitigatedDamage = 0;
+    
+    UPROPERTY(BlueprintReadWrite)
+    float UnmitigatedDamage = 0;
+    
+    UPROPERTY(BlueprintReadWrite)
+    AActor* DamageDealer = nullptr;
+    
+    UPROPERTY(BlueprintReadWrite)
+    AActor* DamageReceiver = nullptr;
+};
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FCogSampleDamageEventDelegate, const FCogSampleDamageEventParams&, Params);
+
+//--------------------------------------------------------------------------------------------------------------------------
+UINTERFACE(MinimalAPI, Blueprintable)
+class UCogSampleDamageableInterface : public UInterface
+{
+    GENERATED_BODY()
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+class ICogSampleDamageableInterface
+{
+    GENERATED_BODY()
+
+public:
+
+    virtual void HandleDamageReceived(const FCogSampleDamageEventParams& Params) {}
+
+    virtual void HandleDamageDealt(const FCogSampleDamageEventParams& Params) {}
+};

Source/CogSample/CogSampleExecCalculation_Damage.cpp

@@ -1,8 +1,11 @@
 #include "CogSampleExecCalculation_Damage.h"
 
+#include "CogSampleAbilitySystemComponent.h"
 #include "CogSampleAttributeSet_Health.h"
 #include "CogSampleCharacter.h"
+#include "CogSampleDamageableInterface.h"
 #include "CogSampleFunctionLibrary_Tag.h"
+#include "CogSampleGameplayEffectContext.h"
 
 //--------------------------------------------------------------------------------------------------------------------------
 struct FCogSampleDamageStatics
@@ -37,22 +40,37 @@ UCogSampleExecCalculation_Damage::UCogSampleExecCalculation_Damage()
 void UCogSampleExecCalculation_Damage::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams, OUT FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
 {
     const FGameplayEffectSpec& EffectSpec = ExecutionParams.GetOwningSpec();
-    const FGameplayEffectContextHandle Context = EffectSpec.GetContext();
+    FGameplayEffectContextHandle EffectContext = EffectSpec.GetContext();
 
     FAggregatorEvaluateParameters EvaluationParameters;
     EvaluationParameters.SourceTags = EffectSpec.CapturedSourceTags.GetAggregatedTags();
     EvaluationParameters.TargetTags = EffectSpec.CapturedTargetTags.GetAggregatedTags();
 
-    UAbilitySystemComponent* TargetAbilitySystem = ExecutionParams.GetTargetAbilitySystemComponent();
-    UAbilitySystemComponent* SourceAbilitySystem = ExecutionParams.GetSourceAbilitySystemComponent();
-    ACogSampleCharacter* TargetCharacter = (TargetAbilitySystem != nullptr) ? Cast<ACogSampleCharacter>(TargetAbilitySystem->AbilityActorInfo.IsValid() ? TargetAbilitySystem->GetAvatarActor() : nullptr) : nullptr;
-    ACogSampleCharacter* SourceCharacter = (SourceAbilitySystem != nullptr) ? Cast<ACogSampleCharacter>(SourceAbilitySystem->AbilityActorInfo.IsValid() ? SourceAbilitySystem->GetAvatarActor() : nullptr) : nullptr;
+    UCogSampleAbilitySystemComponent* TargetAbilitySystem = Cast<UCogSampleAbilitySystemComponent>(ExecutionParams.GetTargetAbilitySystemComponent());
+    AActor* TargetActor = (TargetAbilitySystem != nullptr) ? TargetAbilitySystem->GetAvatarActor() : nullptr;
 
-    if (TargetCharacter == nullptr)
+    UCogSampleAbilitySystemComponent* SourceAbilitySystem = Cast<UCogSampleAbilitySystemComponent>(ExecutionParams.GetSourceAbilitySystemComponent());
+    AActor* SourceActor = (SourceAbilitySystem != nullptr) ? SourceAbilitySystem->GetAvatarActor() : nullptr;
+
+    if (TargetActor == nullptr)
     {
         return;
     }
 
+    FHitResult HitResult;
+    if (const FHitResult* HitResultPtr = EffectContext.GetHitResult())
+    {
+        HitResult = *HitResultPtr;
+    }
+    else
+    {
+        HitResult.Location = TargetActor->GetActorLocation();
+        HitResult.Normal = TargetActor->GetActorForwardVector();
+        HitResult.ImpactNormal = TargetActor->GetActorForwardVector();
+        EffectContext.AddHitResult(HitResult, true);
+    }
+
+
     FGameplayTagContainer SpecAssetTags;
     EffectSpec.GetAllAssetTags(SpecAssetTags);
 
@@ -88,16 +106,75 @@ void UCogSampleExecCalculation_Damage::Execute_Implementation(const FGameplayEff
         OutExecutionOutput.AddOutputModifier(FGameplayModifierEvaluatedData(UCogSampleAttributeSet_Health::GetHealthAttribute(), EGameplayModOp::Additive, -MitigatedDamage));
 
         FCogSampleDamageEventParams Params;
-        Params.DamageDealer = SourceCharacter;
-        Params.DamageReceiver = TargetCharacter;
+        Params.DamageDealer = SourceActor;
+        Params.DamageReceiver = TargetActor;
         Params.MitigatedDamage = MitigatedDamage;
         Params.UnmitigatedDamage = UnmitigatedDamage;
 
-        TargetCharacter->HandleDamageReceived(Params);
-
-        if (SourceCharacter != nullptr)
+        if (ICogSampleDamageableInterface* DamageReceiver = Cast<ICogSampleDamageableInterface>(TargetActor))
         {
-            SourceCharacter->HandleDamageDealt(Params);
+            DamageReceiver->HandleDamageReceived(Params);
+        }
+
+        if (ICogSampleDamageableInterface* DamageDealer = Cast<ICogSampleDamageableInterface>(SourceActor))
+        {
+            DamageDealer->HandleDamageDealt(Params);
         }
     }
+
+    UCogSampleFunctionLibrary_Damage::ExecuteDamageGameplayCue(TargetAbilitySystem, HitResult, MitigatedDamage, EffectContext, false);
 }
+
+//--------------------------------------------------------------------------------------------------------------------------
+void UCogSampleFunctionLibrary_Damage::ExecuteDamageGameplayCue(
+    UCogSampleAbilitySystemComponent* TargetAbilitySystem,
+    const FHitResult& HitResult,
+    float Damage,
+    const FGameplayEffectContextHandle& EffectContext,
+    bool IsPredicted)
+{
+    ensure(TargetAbilitySystem);
+    if (TargetAbilitySystem == nullptr)
+    {
+        return;
+    }
+
+    AActor* TargetActor = TargetAbilitySystem->GetAvatarActor();
+    if (TargetActor == nullptr)
+    {
+        return;
+    }
+
+    FCogSampleGameplayEffectContext* TypedContext = FCogSampleGameplayEffectContext::ExtractEffectContext(EffectContext);
+    ensure(TypedContext);
+    if (TypedContext == nullptr)
+    {
+        return;
+    }
+
+    TypedContext->bGameplayCueIsPredicted = IsPredicted;
+
+    //-----------------------------------------------------------------------------------------------------
+    // We check for >= 1 instead of >= 0 because we can use damage values between 0 and 1.
+    //-----------------------------------------------------------------------------------------------------
+    if (Damage > 0.0f)
+    {
+        FGameplayCueParameters GameplayCueParameters;
+        GameplayCueParameters.RawMagnitude = Damage;
+        GameplayCueParameters.EffectContext = EffectContext;
+        GameplayCueParameters.Instigator = TypedContext->GetInstigator();
+        GameplayCueParameters.EffectCauser = TypedContext->GetEffectCauser();
+        GameplayCueParameters.PhysicalMaterial = HitResult.PhysMaterial;
+        GameplayCueParameters.Location = HitResult.Location;
+        GameplayCueParameters.Normal = HitResult.ImpactNormal;
+
+        if (IsPredicted)
+        {
+            TargetAbilitySystem->ExecuteGameplayCueLocal(Tag_GameplayCue_DamageReceived, GameplayCueParameters);
+        }
+        else
+        {
+            TargetAbilitySystem->ExecuteGameplayCue(Tag_GameplayCue_DamageReceived, GameplayCueParameters);
+        }
+    }
+}

Source/CogSample/CogSampleExecCalculation_Damage.h

@@ -2,8 +2,13 @@
 
 #include "CoreMinimal.h"
 #include "GameplayEffectExecutionCalculation.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
 #include "CogSampleExecCalculation_Damage.generated.h"
 
+class UCogSampleAbilitySystemComponent;
+struct FHitResult;
+struct FGameplayEffectContextHandle;
+
 UCLASS()
 class UCogSampleExecCalculation_Damage : public UGameplayEffectExecutionCalculation
 {
@@ -14,3 +19,20 @@ public:
 
     virtual void Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams, OUT FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const override;
 };
+
+UCLASS(meta = (ScriptName = "CogSampleFunctionLibrary_Damage"))
+class COGSAMPLE_API UCogSampleFunctionLibrary_Damage : public UBlueprintFunctionLibrary
+{
+    GENERATED_BODY()
+
+public:
+
+    UFUNCTION(BlueprintCallable)
+    static void ExecuteDamageGameplayCue(
+        UCogSampleAbilitySystemComponent* TargetAbilitySystem,
+        const FHitResult& HitResult,
+        float HealthDamage,
+        const FGameplayEffectContextHandle& EffectContext,
+        bool IsPredicted);
+
+};

Source/CogSample/CogSampleFunctionLibrary_Tag.cpp

@@ -34,6 +34,8 @@ 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_Hidden, "Effect.Type.Hidden");
 
+UE_DEFINE_GAMEPLAY_TAG(Tag_GameplayCue_DamageReceived, "GameplayCue.DamageReceived");
+
 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");

Source/CogSample/CogSampleFunctionLibrary_Tag.h

@@ -36,6 +36,8 @@ 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_Hidden);
 
+UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_GameplayCue_DamageReceived);
+
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Dead);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Ghost);
 UE_DECLARE_GAMEPLAY_TAG_EXTERN(Tag_Status_Immobilized);

Source/CogSample/CogSampleGameState.cpp

@@ -164,8 +164,7 @@ void ACogSampleGameState::InitializeCog()
     CogWindowManager->CreateWindow<UCogEngineWindow_Plots>("Engine.Plots");
 
     UCogEngineWindow_Selection* SelectionWindow = CogWindowManager->CreateWindow<UCogEngineWindow_Selection>("Engine.Selection");
-    SelectionWindow->SetActorSubClasses({ AActor::StaticClass(), AGameModeBase::StaticClass(), AGameStateBase::StaticClass(), ACharacter::StaticClass() });
-    SelectionWindow->SetCurrentActorSubClass(ACharacter::StaticClass());
+    SelectionWindow->SetActorClasses({ ACharacter::StaticClass(), AActor::StaticClass(), AGameModeBase::StaticClass(), AGameStateBase::StaticClass() });
     SelectionWindow->SetTraceType(UEngineTypes::ConvertToTraceType(ECollisionChannel::ECC_Pawn));
 
     CogWindowManager->CreateWindow<UCogEngineWindow_Scalability>("Engine.Scalability");

Source/CogSample/CogSampleGameplayEffectContext.cpp

@@ -249,4 +249,15 @@ void UCogSampleEffectContextLibrary::EffectContextGetAllFloatValues(FGameplayEff
     {
         Entries = TypedEffectContext->FloatValues;
     }
-}
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool UCogSampleEffectContextLibrary::EffectContextGetGameplayCueIsPredicted(FGameplayEffectContextHandle EffectContext)
+{
+    if (FCogSampleGameplayEffectContext* TypedEffectContext = FCogSampleGameplayEffectContext::ExtractEffectContext(EffectContext))
+    {
+        return TypedEffectContext->bGameplayCueIsPredicted;
+    }
+
+    return false;
+}

Source/CogSample/CogSampleGameplayEffectContext.h

@@ -65,6 +65,11 @@ public:
 
     bool CanGameplayCueBePredicted();
 
+    /* NOT REPLICATED - Is this effect context made for a local gameplay cue. Used to know if a remote gameplay cue
+    * created by the local player should be filtered when a local gameplay cue is played instead.
+    */
+    bool bGameplayCueIsPredicted = false;
+
     /* REPLICATED */
     UPROPERTY()
     TArray<FCogSampleGameplayEffectContextFloatValue> FloatValues;
@@ -91,6 +96,9 @@ class UCogSampleEffectContextLibrary : public UBlueprintFunctionLibrary
 
 public:
 
+    UFUNCTION(BlueprintPure)
+    static bool EffectContextGetGameplayCueIsPredicted(FGameplayEffectContextHandle EffectContext);
+
     UFUNCTION(BlueprintCallable)
     static void EffectContextSetFloatValue(FGameplayEffectContextHandle EffectContext, FName Name, float Value);
 

Source/CogSample/CogSampleLogCategories.h

@@ -1,4 +1,5 @@
 #pragma once
+
 #include "CoreMinimal.h"
 
 DECLARE_LOG_CATEGORY_EXTERN(LogCogAlways, VeryVerbose, All);