mirror of
https://github.com/Ed94/Cog.git
synced 2026-07-26 01:13:47 +00:00
Add more abilities in the sample
This commit is contained in:
Arnaud Jamin
@@ -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;
|
||||
};
|
||||
+3
-3
@@ -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;
|
||||
};
|
||||
Reference in New Issue
Block a user