49. UE5 RPG 使用Execution Calculations处理对目标造成的最终伤害

Execution Calculations是Unreal Engine中Gameplay Effects系统的一部分，用于在Gameplay Effect执行期间进行自定义的计算和逻辑操作。它允许开发者根据特定的游戏需求，灵活地处理和修改游戏中的属性（Attributes）。

功能强大且灵活：与ModifierMagnitudeCalculation类似，Execution Calculations可以捕获Attribute，并可选择性地为其创建Snapshot。不过，与MMC不同的是，Execution Calculations可以修改多个Attribute，基本上可以处理程序员想要做的任何事。
不可预测性：这种强大和灵活性的代价是它是不可预测的（Modifiers是可以预测的），且必须在C++中实现。这是因为Execution Calculations提供了很高的自由度，允许开发者根据特定的游戏逻辑进行自定义计算。
使用场景：Execution Calculations最普遍的应用场景是计算一个来自很多源（Source）和目标（Target）中Attribute伤害值的复杂公式。例如，在计算伤害时，可以考虑攻击者的攻击力、防御者的防御力、各种增益和减益效果等多个因素。
限制：需要注意的是，Execution Calculations只能由即刻（Instant）和周期性（Periodic）Gameplay Effect使用。功能强大也带来了劣势就是它不支持预测（Prediction）。属性获取时不会运行PreAttributeChange函数，所以，我们还需要在其内部实现一遍属性限制。只能够在服务器运行并且在Net Execution Policies设置为 Local Predicted，Server Initiated和Server Only时。

它和GameplayModMagnitudeCalculation很像，但是可以一次性修改多个属性。它不是只返回一个值，而是直接在函数内部对属性进行了修改。
由于Execution Calculations的复杂性，建议进行充分的测试和调试，以确保计算逻辑的正确性。

关于快照 Snapshoting，如果选择了它，快照的属性值将会在GE的Spec创建的时候设置，如果不选择，那它将会在应用GE时去获取属性值。注意，即使我们选择快照，目标的属性也是在应用GE时获取，没应用之前我们也不知道目标是谁。

创建类

接下来，我们将使用Execution Calculations来实现对技能伤害的计算，我们创建一个基于GameplayEffectExecutionCalculation的类
在这里插入图片描述
然后创建类，并专门设置一个文件夹存储同类型的类

在.h文件中，我们需要设置构造函数，和覆写父类的函数，在函数内进行逻辑处理

// 版权归暮志未晚所有。

#pragma once

#include "CoreMinimal.h"
#include "GameplayEffectExecutionCalculation.h"
#include "ExecCalc_Damage.generated.h"

/**
 * 
 */
UCLASS()
class AURA_API UExecCalc_Damage : public UGameplayEffectExecutionCalculation
{
	GENERATED_BODY()

public:
	UExecCalc_Damage();

	virtual void Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams, FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const override;
};

捕获属性

在C++中，我们首先实现通过快照获取到属性，它和我们之前制作的获取最大生命值和最大蓝量值的MMC里面的获取方式一致，在MMC里面，我们在构造函数内进行获取属性的设置，然后通过函数获取属性的值。
在这里插入图片描述
我们在C++中，首先创建一个结构体，由于不需要外部使用，所以不需要用F开头，方便区分

//这里结构体不加F是因为它是内部结构体，不需要外部获取，也不需要在蓝图中使用
struct SDamageStatics 
{
	SDamageStatics()
	{
		
	}
};

然后创建一个静态函数，这个函数返回一个静态实例，由于这个实例是静态的，因此它只会被创建一次，并且在随后的函数调用中重复使用。这种模式也称为单例模式（Singleton Pattern）。

static const SDamageStatics& DamageStatics()
{
	static SDamageStatics DStatics;
	return DStatics;
}

接下来，我们将在结构体内增加需要快照的属性，为了方便定义快照，gas里面也给我们定义相应的宏，我们不需要每次像在mmc里面那么复杂的去定义每个属性。
以下为gas代码定义的宏，一个用于申明属性，另一个则是实现了在构造函数中实现的赋值创建。

// -------------------------------------------------------------------------
//	Helper macros for declaring attribute captures 
// -------------------------------------------------------------------------

#define DECLARE_ATTRIBUTE_CAPTUREDEF(P) \
	FProperty* P##Property; \
	FGameplayEffectAttributeCaptureDefinition P##Def; \

#define DEFINE_ATTRIBUTE_CAPTUREDEF(S, P, T, B) \
{ \
	P##Property = FindFieldChecked<FProperty>(S::StaticClass(), GET_MEMBER_NAME_CHECKED(S, P)); \
	P##Def = FGameplayEffectAttributeCaptureDefinition(P##Property, EGameplayEffectAttributeCaptureSource::T, B); \
}

有了这两个宏，我们就创建快照代码就简洁了很多。我们使用宏定义属性，然后在构造是定义参数，即可完成对属性相关内容的创建，比之前简洁了很多。

struct SDamageStatics 
{
	DECLARE_ATTRIBUTE_CAPTUREDEF(Armor);
	SDamageStatics()
	{
		//参数：1.属性集 2.属性名 3.目标还是自身 4.是否设置快照（true为创建时获取，false为应用时获取）
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, Armor, Target, false);
	}
};

还有最后一步，就是需要将属性添加到捕获列表中，我们在构造函数中添加即可。

UExecCalc_Damage::UExecCalc_Damage()
{
	RelevantAttributesToCapture.Add(DamageStatics().ArmorDef);
}

以后，我们将需要的属性都按照这种方式实现即可。

Execute_Implementation

接下来就是主要的执行函数，也是我们需要覆写的内容，它有两个值：

ExecutionParams：这是一个包含自定义执行参数的结构体，它提供了执行此游戏效果所需的所有信息。
OutExecutionOutput：这是一个输出参数，用于存储执行结果或相关的输出信息。

在ExecutionParams里，我们可以获取到需要用于计算的对象，并从它身上获取相关内容。
下面相当于是一个模板的内容，以后制作相关的，我们可以直接复制使用

void UExecCalc_Damage::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams,
                                              FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
{
	//获取ASC
	const UAbilitySystemComponent* SourceASC = ExecutionParams.GetSourceAbilitySystemComponent();
	const UAbilitySystemComponent* TargetASC = ExecutionParams.GetTargetAbilitySystemComponent();

	//获取AvatarActor
	const AActor* SourceAvatar = SourceASC ? SourceASC->GetAvatarActor() : nullptr;
	const AActor* TargetAvatar = TargetASC ? TargetASC->GetAvatarActor() : nullptr;

	//获取挂载此类的GE实例
	const FGameplayEffectSpec& Spec = ExecutionParams.GetOwningSpec();

	//设置评估参数
	const FGameplayTagContainer* SourceTags = Spec.CapturedSourceTags.GetAggregatedTags();
	const FGameplayTagContainer* TargetTags = Spec.CapturedTargetTags.GetAggregatedTags();
	FAggregatorEvaluateParameters EvaluationParameters;
	EvaluationParameters.SourceTags = SourceTags;
	EvaluationParameters.TargetTags = TargetTags;

然后，我们可以对属性进行获取

	//获取护甲
	float Armor = 0.f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().ArmorDef, EvaluationParameters, Armor);
	Armor = FMath::Max(0.f, Armor);

接着就是最重要的一步，在返回接口，我们需要通过FGameplayModifierEvaluatedData 创建所需的计算，这里，我们对目标的护甲加上当前的护甲，相当于，我们攻击它，它的护甲增加了一倍。

	//输出计算结果
	const FGameplayModifierEvaluatedData EvaluatedData(DamageStatics().ArmorProperty, EGameplayModOp::Additive, Armor);
	OutExecutionOutput.AddOutputModifier(EvaluatedData);

在计算方式这里，我们可以选择多种计算方式，和在蓝图中设置一样。
在这里插入图片描述
接着编译打开UE，在Executions数组中增加一项，将我们创建的类设置上去。

在最终输出这里打个断点，查看每次是否Armor会增加一倍

第一次获取的值是

第二次是

刚好是一倍，证明逻辑正确。

使用Execution Calculations实现Set by Caller

我们之前实现伤害时通过Set by Caller通过标签传入值对角色造成的伤害，这里，我们将不使用这种方式，修改为使用Execution Calculations来实现当前的逻辑。
首先，我们将之前制作的Set by Caller的配置删除掉，不用了
在这里插入图片描述
然后通过在代码里配置去获取Set by Caller，这里为了区分，将伤害减少10，原来伤害时100，现在就应该是90

	//从Set by Caller 获取Damage的伤害值
	float Damage = Spec.GetSetByCallerMagnitude(FMyGameplayTags::Get().Damage);
	Damage -= 10;

最后设置时，我们需要设置给IncomingDamage，我们这里直接从属性集上面获取对应的属性

	//输出计算结果
	const FGameplayModifierEvaluatedData EvaluatedData(UAttributeSetBase::GetIncomingDamageAttribute(), EGameplayModOp::Additive, Damage);
	OutExecutionOutput.AddOutputModifier(EvaluatedData);

编译查看结果
在这里插入图片描述

计算格挡率影响伤害

接下来，我们使用格挡率来计算是否被格挡。首先要增加对格挡率的值的获取，和护甲一样，我们需要去获取，这里不在赘述。

struct SDamageStatics 
{
	DECLARE_ATTRIBUTE_CAPTUREDEF(Armor);
	DECLARE_ATTRIBUTE_CAPTUREDEF(BlockChance);
	
	SDamageStatics()
	{
		//参数：1.属性集 2.属性名 3.目标还是自身 4.是否设置快照（true为创建时获取，false为应用时获取）
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, Armor, Target, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, BlockChance, Target, false);
	}
};

UExecCalc_Damage::UExecCalc_Damage()
{
	RelevantAttributesToCapture.Add(DamageStatics().ArmorDef);
	RelevantAttributesToCapture.Add(DamageStatics().BlockChanceDef);
}

然后我们获取到格挡率，并防止它会出现负值

//获取格挡率，如果触发格挡，伤害减少一半
float TargetBlockChance = 0.f;
ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().BlockChanceDef, EvaluationParameters, TargetBlockChance);
TargetBlockChance = FMath::Max(0.f, TargetBlockChance);

然后，我们生成一个从1到一百的随机数，并和格挡率进行判断，随机数小于格挡率的值，则触发伤害减半

//处理格挡触发
if(FMath::RandRange(1, 100) < TargetBlockChance) Damage *= 0.5f;

对于格挡率的测试，我们完全可以创建一个测试用的GE去测试效果。

使用护甲和护甲穿透影响伤害

接下来，我们还需要通过应用角色护甲值（目标）和护甲穿透（源）来影响伤害
首先获取对应的值，我们在结构体内增加对应的宏

struct SDamageStatics 
{
	DECLARE_ATTRIBUTE_CAPTUREDEF(Armor);
	DECLARE_ATTRIBUTE_CAPTUREDEF(ArmorPenetration);
	DECLARE_ATTRIBUTE_CAPTUREDEF(BlockChance);
	
	SDamageStatics()
	{
		//参数：1.属性集 2.属性名 3.目标还是自身 4.是否设置快照（true为创建时获取，false为应用时获取）
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, Armor, Target, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, BlockChance, Target, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, ArmorPenetration, Source, false);
	}
};

然后构造函数添加到捕获列表

UExecCalc_Damage::UExecCalc_Damage()
{
	RelevantAttributesToCapture.Add(DamageStatics().ArmorDef);
	RelevantAttributesToCapture.Add(DamageStatics().BlockChanceDef);
	RelevantAttributesToCapture.Add(DamageStatics().ArmorPenetrationDef);
}

接着在函数内，获取两个属性

//获取目标护甲值
float TargetArmor = 0.f;
ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().ArmorDef, EvaluationParameters, TargetArmor);
TargetArmor = FMath::Max(0.f, TargetArmor);
//获取源护甲穿透
float SourceArmorPenetration = 0.f;
ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().ArmorPenetrationDef, EvaluationParameters, SourceArmorPenetration);
SourceArmorPenetration = FMath::Max(0.f, SourceArmorPenetration);

然后计算护甲穿透影响护甲值

	//护甲穿透将按照比例忽略目标的护甲值，护甲穿透的值可以根据某个方程计算出实际护甲穿透率（可以根据等级，等级越高，每一点护甲穿透值的比例越低）
	const float EffectiveArmor = TargetArmor * (100.f - SourceArmorPenetration * 0.25f) / 100.f;

再计算护甲减少伤害

	//忽略后的护甲值将以一定比例影响伤害
	Damage *= (100.f - EffectiveArmor * 0.333f) / 100.f;

这样完成了护甲减少伤害的功能。

使用曲线表格修改护甲穿透和护甲的影响

在上面，我们在使用护甲穿透和护甲时，又乘以了一个数值来调整它们的影响。这是为了在RPG游戏中，前期游戏数值低，后期数值高，导致值的影响前期太低或者后期太高，所以，我们将其设置为一个可以跟随等级变动的数值，来让前期低数值时获取一个不错的比例，并且在高等级时，也能不会导致数值溢出的问题。
我们创建一个曲线表格来实现数值的设置，类型选择Constant
在这里插入图片描述
进入曲线表格，修改名称，比如第一行去修改护甲穿透，然后点击加新的一列

添加数值时，如果想修改更多的key，可以三个点来修改

添加完数值

如果你想查看每个等级获取到的值到底是多少，可以切换到曲线查看，会发现在constant模式下，它在补间中间获取的都是自己设定的值，而且还可以检查是否出现错误。
在这里插入图片描述
接着填完对应的数值

接着打开代码编辑器，在之前设置的配置属性类中设置CharacterClassInfo中添加一个设置曲线表格的配置项

	UPROPERTY(EditDefaultsOnly, Category="Common Class Defaults|Damgage")
	TObjectPtr<UCurveTable> DamageCalculationCoefficients;

为了方便我们去获取当前在GameMode上面配置的数据，我们在静态函数库里面创建一个函数来获取数据。

	//获取角色配置数据
	UFUNCTION(BlueprintCallable, Category="MyAbilitySystemLibrary|CharacterClassDefaults")
	static UCharacterClassInfo* GetCharacterClassInfo(const UObject* WorldContextObject);

实现我们之前在其它函数实现了很多次了，就是获取到GameMode实例，然后从实例上获取到配置

UCharacterClassInfo* UMyAbilitySystemBlueprintLibrary::GetCharacterClassInfo(const UObject* WorldContextObject)
{
	//获取到当前关卡的GameMode实例
	const AMyGameModeBase* GameMode = Cast<AMyGameModeBase>(UGameplayStatics::GetGameMode(WorldContextObject));
	if(GameMode == nullptr) return nullptr;

	//返回关卡的角色的配置
	return  GameMode->CharacterClassInfo;
}

接着我们回到ExecCalc_Damage处理函数中，通过这个函数获取到角色数据使用

//获取到角色配置数据
const UCharacterClassInfo* CharacterClassInfo = UMyAbilitySystemBlueprintLibrary::GetCharacterClassInfo(SourceAvatar);

为了获取等级，我们需要将Avatar转换为战斗接口，然后通过接口内的函数获取角色等级

	//获取AvatarActor
	AActor* SourceAvatar = SourceASC ? SourceASC->GetAvatarActor() : nullptr;
	AActor* TargetAvatar = TargetASC ? TargetASC->GetAvatarActor() : nullptr;

	//获取到战斗接口
	ICombatInterface* SourceCombatInterface = Cast<ICombatInterface>(SourceAvatar);
	ICombatInterface* TargetCombatInterface = Cast<ICombatInterface>(TargetAvatar);

数据有了，等级有了，就可以去获取对应的系数
首先处理护甲穿透的系数，我们先通过数据配置项获取到哪一行的数据，然后通过数据以及角色的等级去获取系数
然后将值替换掉

//获取到数据表内的护甲穿透系数
const FRealCurve* ArmorPenetrationCurve = CharacterClassInfo->DamageCalculationCoefficients->FindCurve(FName("ArmorPenetration"), FString());
const float ArmorPenetrationCoefficient = ArmorPenetrationCurve->Eval(SourceCombatInterface->GetPlayerLevel());
//护甲穿透将按照比例忽略目标的护甲值，护甲穿透的值可以根据某个方程计算出实际护甲穿透率（可以根据等级，等级越高，每一点护甲穿透值的比例越低）
const float EffectiveArmor = TargetArmor * (100.f - SourceArmorPenetration * ArmorPenetrationCoefficient) / 100.f;

接着是护甲的系数，同理，注意，护甲穿透是获取源的，而护甲时获取的目标的不要弄错

//获取到数据表内的护甲系数
const FRealCurve* EffectiveArmorCurve = CharacterClassInfo->DamageCalculationCoefficients->FindCurve(FName("EffectiveArmor"), FString());
const float EffectiveArmorCoefficient = EffectiveArmorCurve->Eval(TargetCombatInterface->GetPlayerLevel());
//忽略后的护甲值将以一定比例影响伤害
Damage *= (100.f - EffectiveArmor * EffectiveArmorCoefficient) / 100.f;

这样就实现了代码逻辑，编译打开UE，在UE里，我们首先将曲线表格设置到数据资产上
在这里插入图片描述
接下来就是测试，我这里debug好像有点问题，获取不到ExecutionParams内容，所以采用打印的方式，来查看系数

实现暴击

我们还将在这里面实现暴击修改最终伤害的逻辑，同理，这里就简单讲解一下，
先增加一条影响暴击抵抗的系数曲线
在这里插入图片描述

在代码中增加获取到源的暴击概率和暴击伤害，以及目标的暴击抵抗

struct SDamageStatics 
{
	...
	DECLARE_ATTRIBUTE_CAPTUREDEF(CriticalHitChance);
	DECLARE_ATTRIBUTE_CAPTUREDEF(CriticalHitDamage);
	DECLARE_ATTRIBUTE_CAPTUREDEF(CriticalHitResistance);
	
	SDamageStatics()
	{
		//参数：1.属性集 2.属性名 3.目标还是自身 4.是否设置快照（true为创建时获取，false为应用时获取）
		...
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, CriticalHitChance, Source, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, CriticalHitDamage, Source, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, CriticalHitResistance, Target, false);
	}
};

...

UExecCalc_Damage::UExecCalc_Damage()
{
	...
	RelevantAttributesToCapture.Add(DamageStatics().CriticalHitChanceDef);
	RelevantAttributesToCapture.Add(DamageStatics().CriticalHitDamageDef);
	RelevantAttributesToCapture.Add(DamageStatics().CriticalHitResistanceDef);
}

然后还是老套路，增加暴击伤害的逻辑处理，获取数据，处理数据

//--------------------暴击伤害--------------------
//暴击率
float SourceCriticalHitChance = 0.f;
ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().CriticalHitChanceDef, EvaluationParameters, SourceCriticalHitChance);
SourceCriticalHitChance = FMath::Max(0.f, SourceCriticalHitChance);
//暴击伤害
float SourceCriticalHitDamage = 0.f;
ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().CriticalHitDamageDef, EvaluationParameters, SourceCriticalHitDamage);
SourceCriticalHitDamage = FMath::Max(0.f, SourceCriticalHitDamage);
//暴击抵抗
float TargetCriticalHitResistance = 0.f;
ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().CriticalHitResistanceDef, EvaluationParameters, TargetCriticalHitResistance);
TargetCriticalHitResistance = FMath::Max(0.f, TargetCriticalHitResistance);
//获取到数据表内的暴击抵抗系数
const FRealCurve* CriticalHitResistanceCurve = CharacterClassInfo->DamageCalculationCoefficients->FindCurve(FName("CriticalHitResistance"), FString());
const float CriticalHitResistanceCoefficient = CriticalHitResistanceCurve->Eval(TargetCombatInterface->GetPlayerLevel());
//计算当前是否暴击
const float EffectiveCriticalHitChance = SourceCriticalHitChance - TargetCriticalHitResistance * CriticalHitResistanceCoefficient;
const bool bCriticalHit = FMath::RandRange(1, 100) < EffectiveCriticalHitChance;
//触发暴击 伤害乘以暴击伤害率
if(bCriticalHit) Damage = Damage * 2.f + SourceCriticalHitDamage;

我刚才测试了一下，如果不暴击的话伤害是5，暴击伤害是25 。这个值是两倍的伤害+暴击伤害 5*2 + 14.67约等于25 没问题。
在这里插入图片描述

源码

// 版权归暮志未晚所有。


#include "AbilitySystem/ExecCalc/ExecCalc_Damage.h"

#include "AbilitySystemComponent.h"
#include "MyGameplayTags.h"
#include "AbilitySystem/AttributeSetBase.h"
#include "AbilitySystem/MyAbilitySystemBlueprintLibrary.h"
#include "AbilitySystem/Data/CharacterClassInfo.h"
#include "Interaction/CombatInterface.h"

//这里结构体不加F是因为它是内部结构体，不需要外部获取，也不需要在蓝图中使用
struct SDamageStatics 
{
	DECLARE_ATTRIBUTE_CAPTUREDEF(Armor);
	DECLARE_ATTRIBUTE_CAPTUREDEF(ArmorPenetration);
	DECLARE_ATTRIBUTE_CAPTUREDEF(BlockChance);
	DECLARE_ATTRIBUTE_CAPTUREDEF(CriticalHitChance);
	DECLARE_ATTRIBUTE_CAPTUREDEF(CriticalHitDamage);
	DECLARE_ATTRIBUTE_CAPTUREDEF(CriticalHitResistance);
	
	SDamageStatics()
	{
		//参数：1.属性集 2.属性名 3.目标还是自身 4.是否设置快照（true为创建时获取，false为应用时获取）
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, Armor, Target, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, BlockChance, Target, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, ArmorPenetration, Source, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, CriticalHitChance, Source, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, CriticalHitDamage, Source, false);
		DEFINE_ATTRIBUTE_CAPTUREDEF(UAttributeSetBase, CriticalHitResistance, Target, false);
	}
};

static const SDamageStatics& DamageStatics()
{
	static SDamageStatics DStatics;
	return DStatics;
}

UExecCalc_Damage::UExecCalc_Damage()
{
	RelevantAttributesToCapture.Add(DamageStatics().ArmorDef);
	RelevantAttributesToCapture.Add(DamageStatics().BlockChanceDef);
	RelevantAttributesToCapture.Add(DamageStatics().ArmorPenetrationDef);
	RelevantAttributesToCapture.Add(DamageStatics().CriticalHitChanceDef);
	RelevantAttributesToCapture.Add(DamageStatics().CriticalHitDamageDef);
	RelevantAttributesToCapture.Add(DamageStatics().CriticalHitResistanceDef);
}

void UExecCalc_Damage::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams,
                                              FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
{
	//获取ASC
	const UAbilitySystemComponent* SourceASC = ExecutionParams.GetSourceAbilitySystemComponent();
	const UAbilitySystemComponent* TargetASC = ExecutionParams.GetTargetAbilitySystemComponent();

	//获取AvatarActor
	AActor* SourceAvatar = SourceASC ? SourceASC->GetAvatarActor() : nullptr;
	AActor* TargetAvatar = TargetASC ? TargetASC->GetAvatarActor() : nullptr;

	//获取到战斗接口
	ICombatInterface* SourceCombatInterface = Cast<ICombatInterface>(SourceAvatar);
	ICombatInterface* TargetCombatInterface = Cast<ICombatInterface>(TargetAvatar);

	//获取挂载此类的GE实例
	const FGameplayEffectSpec& Spec = ExecutionParams.GetOwningSpec();

	//设置评估参数
	const FGameplayTagContainer* SourceTags = Spec.CapturedSourceTags.GetAggregatedTags();
	const FGameplayTagContainer* TargetTags = Spec.CapturedTargetTags.GetAggregatedTags();
	FAggregatorEvaluateParameters EvaluationParameters;
	EvaluationParameters.SourceTags = SourceTags;
	EvaluationParameters.TargetTags = TargetTags;

	//获取到角色配置数据
	const UCharacterClassInfo* CharacterClassInfo = UMyAbilitySystemBlueprintLibrary::GetCharacterClassInfo(SourceAvatar);

	//从Set by Caller 获取Damage的伤害值
	float Damage = Spec.GetSetByCallerMagnitude(FMyGameplayTags::Get().Damage);

	//--------------------处理格挡路--------------------
	//获取格挡率，如果触发格挡，伤害减少一半
	float TargetBlockChance = 0.f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().BlockChanceDef, EvaluationParameters, TargetBlockChance);
	TargetBlockChance = FMath::Max(0.f, TargetBlockChance);
	//根据格挡概率判断当前是否触发
	const bool bBlocked = FMath::RandRange(1, 100) < TargetBlockChance;
	if(bBlocked) Damage *= 0.5f;

	//--------------------处理目标护甲和源的护甲穿透影响伤害--------------------
	//获取目标护甲值
	float TargetArmor = 0.f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().ArmorDef, EvaluationParameters, TargetArmor);
	TargetArmor = FMath::Max(0.f, TargetArmor);
	//获取源护甲穿透
	float SourceArmorPenetration = 0.f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().ArmorPenetrationDef, EvaluationParameters, SourceArmorPenetration);
	SourceArmorPenetration = FMath::Max(0.f, SourceArmorPenetration);
	//获取到数据表内的护甲穿透系数
	const FRealCurve* ArmorPenetrationCurve = CharacterClassInfo->DamageCalculationCoefficients->FindCurve(FName("ArmorPenetration"), FString());
	const float ArmorPenetrationCoefficient = ArmorPenetrationCurve->Eval(SourceCombatInterface->GetPlayerLevel());
	//护甲穿透将按照比例忽略目标的护甲值，护甲穿透的值可以根据某个方程计算出实际护甲穿透率（可以根据等级，等级越高，每一点护甲穿透值的比例越低）
	const float EffectiveArmor = TargetArmor * (100.f - SourceArmorPenetration * ArmorPenetrationCoefficient) / 100.f;
	//获取到数据表内的护甲系数
	const FRealCurve* EffectiveArmorCurve = CharacterClassInfo->DamageCalculationCoefficients->FindCurve(FName("EffectiveArmor"), FString());
	const float EffectiveArmorCoefficient = EffectiveArmorCurve->Eval(TargetCombatInterface->GetPlayerLevel());
	//忽略后的护甲值将以一定比例影响伤害
	Damage *= (100.f - EffectiveArmor * EffectiveArmorCoefficient) / 100.f;

	//--------------------暴击伤害--------------------
	//暴击率
	float SourceCriticalHitChance = 0.f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().CriticalHitChanceDef, EvaluationParameters, SourceCriticalHitChance);
	SourceCriticalHitChance = FMath::Max(0.f, SourceCriticalHitChance);
	//暴击伤害
	float SourceCriticalHitDamage = 0.f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().CriticalHitDamageDef, EvaluationParameters, SourceCriticalHitDamage);
	SourceCriticalHitDamage = FMath::Max(0.f, SourceCriticalHitDamage);
	//暴击抵抗
	float TargetCriticalHitResistance = 0.f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().CriticalHitResistanceDef, EvaluationParameters, TargetCriticalHitResistance);
	TargetCriticalHitResistance = FMath::Max(0.f, TargetCriticalHitResistance);
	//获取到数据表内的暴击抵抗系数
	const FRealCurve* CriticalHitResistanceCurve = CharacterClassInfo->DamageCalculationCoefficients->FindCurve(FName("CriticalHitResistance"), FString());
	const float CriticalHitResistanceCoefficient = CriticalHitResistanceCurve->Eval(TargetCombatInterface->GetPlayerLevel());
	//计算当前是否暴击
	const float EffectiveCriticalHitChance = SourceCriticalHitChance - TargetCriticalHitResistance * CriticalHitResistanceCoefficient;
	const bool bCriticalHit = FMath::RandRange(1, 100) < EffectiveCriticalHitChance;
	//触发暴击 伤害乘以暴击伤害率
	if(bCriticalHit) Damage = Damage * 2.f + SourceCriticalHitDamage;

	//输出计算结果
	const FGameplayModifierEvaluatedData EvaluatedData(UAttributeSetBase::GetIncomingDamageAttribute(), EGameplayModOp::Additive, Damage);
	OutExecutionOutput.AddOutputModifier(EvaluatedData);
}