What are meta attributes and how to use them

Most commonly, and in this example, a meta attribute will be used for damage. Meta attributes are placeholder attributes that act as intermediaries on which we perform all the necessary calculations before damage is actually applied. For projects that have more complex damage handling in which certain calculations should be performed before damage is applied (armor, buffs, resistances etc.), a meta attribute is a good choice. Meta attributes are also useful because they separate concerns between the damage dealer and the target, as the damage dealer doesn't need to know how the target handles its damage. Meta attributes are typically not replicated.

Making a meta attribute

To make a damage meta attribute, you can make a regular attribute in your attribute set, which won't be replicated as damage should only be handled on the server, so there's no need for a GetLifetimeReplicatedProps entry or an OnRep.

UPROPERTY(BlueprintReadOnly, Category = "Meta Attributes")
FGameplayAttributeData IncomingDamage;

ATTRIBUTE_ACCESSORS(ThisClass, IncomingDamage)

Using a meta attribute

To use the meta attribute, in PostGameplayEffectExecute, we can store the value of this meta attribute in a local variable to use it later, and immediately zero out the attribute so that any new damage starts at 0 instead of adding to previous values. Now, we can have a check for if the damage is above 0, in which case we can subtract from our health attribute with it, and then set the health to the result of that subtraction while clamping. Optionally, you can now also check if health is at or below 0.

if (Data.EvaluatedData.Attribute == GetIncomingDamageAttribute())
{
    const float LocalIncomingDamage = GetIncomingDamage();
    SetIncomingDamage(0.f);
    if (LocalIncomingDamage > 0.f)
    {
        const float NewHealth = GetHealth() - LocalIncomingDamage;
        SetHealth(FMath::Clamp(NewHealth, 0.f, GetMaxHealth()));

        const bool bFatal = NewHealth <= 0.f;
    }
}

The meta attribute is now ready to be used in ExecCalcs. The value that the ExecCalc outputs will be used here.

What are execution calculations and how to use them

Execution calculations (commonly abbreviated as ExecCalc) are the most powerful and custom way to modify gameplay effects, such as the gameplay effect we will use to apply damage in this case. As opposed to magnitude calculation classes (MMC) which can only change one attribute, ExecCalcs are capable of changing multiple attributes.

There are some important caveats to using ExecCalcs:

1. They don't support prediction

2. They can only be used for instant and periodic gameplay effects (no infinite gameplay effects, but duration effects with periods can be used)

3. Capturing attributes doesn't run PreAttributeChange, so any clamping must be done again

4. They are only executed on the server from gameplay abilities with local predicted, server initiated, and server only net execution policies

Snapshotting is another feature of ExecCalcs, and it captures the attribute value when the gameplay effect spec is created. Otherwise, when not snapshotting, attribute values are captured when the gameplay effect is applied. From the target, the values are always captured on effect application only - snapshotting only applies to the source. In other words, should an ability's damage be locked when the ability is activated or read when it hits the target it should apply damage to? This difference matters when you have something like buffs that can expire in between.

Execution calculations are also capable of taking in set by caller magnitudes and using them in calculations, and they also supports calculation modifiers.

The execution calculation class is created by inheriting from the UGameplayEffectExecutionCalculation class, and is assigned in the Executions section of your gameplay effect.

Using an execution calculation class

The main function of ExecCalcs is the public Execute_Implementation.

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

This function's first parameter is a const reference for execution parameters of the gameplay effect that's being applied, and the second parameter is a reference to the output of those same parameters, which is how this function modifies attributes (which will be seen later). The ExecutionParams can be used to access different kinds of information, for example:

const UAbilitySystemComponent* SourceASC = ExecutionParams.GetSourceAbilitySystemComponent();
const UAbilitySystemComponent* TargetASC = ExecutionParams.GetTargetAbilitySystemComponent();

AActor* SourceAvatar = SourceASC ? SourceASC->GetAvatarActor() : nullptr;
AActor* TargetAvatar = TargetASC ? TargetASC->GetAvatarActor() : nullptr;
const FGameplayEffectSpec& Spec = ExecutionParams.GetOwningSpec();

Note: In this post I won't cover capturing attributes or using their values in calculations. Instead I'll use a set by caller magnitude and feed its value directly into the damage meta attribute, just enough to show the ExecCalc → meta attribute pipeline clearly. I'll cover attribute capturing as a follow-up post.

Passing in a set by caller magnitude to the damage gameplay effect

The way you handle applying the damage effect with your set by caller magnitude will depend heavily on how your code is set up. In my case, I have a function that all gameplay abilities that deal damage will have due to inheritance, which simply just makes the effect spec, gets that ability's damage (based on level), then assigns the set by caller magnitude with a damage type tag, and applies the gameplay effect to the target actor.

// DamageEffectClass is a TSubclassOf of the damage gameplay effect
FGameplayEffectSpecHandle DamageSpecHandle = MakeOutgoingGameplayEffectSpec(
DamageEffectClass, 1.f);

// The magnitude in my case is an FScalableFloat damage based on that ability's level. 
// You can also just use regular floats here.
const float ScaledDamage = Damage.GetValueAtLevel(GetAbilityLevel());

// DamageType is a FGameplayTag variable for damage types set in the blueprints of my damage abilities, you can pass in any tag you want 
UAbilitySystemBlueprintLibrary::AssignTagSetByCallerMagnitude(
DamageSpecHandle, DamageType, ScaledDamage);

GetAbilitySystemComponentFromActorInfo()->ApplyGameplayEffectSpecToTarget(
*DamageSpecHandle.Data.Get(), 
UAbilitySystemBlueprintLibrary::GetAbilitySystemComponent(TargetActor));

Getting set by caller magnitude values in the execution calculation and modifying attributes

Now that we pass in a set by caller magnitude to the gameplay effect that has the execution calculation set, we can get that magnitude, and in this case, just add that magnitude to our IncomingDamage meta attribute.

To do this, we first need to get the gameplay effect's spec (the one that has the ExecCalc set). Then, we can store that damage by creating a local variable and getting the set by caller magnitude with our tag that we passed in when applying it. The last step is to create a const FGameplayModifierEvaluatedData struct, which when initializing requires the attribute you want to modify (our meta attribute in this case), in what way you want to modify it, and the variable to modify it with. After the struct is initialized, you can call AddOutputModifier on the OutExecutionOutput , and pass in our initialized struct.

void UExecCalc_Damage::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams,                                           FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
{
    const FGameplayEffectSpec& Spec = ExecutionParams.GetOwningSpec();

    // Here I check my custom damage type tag to see if it was used to apply the set by caller magnitude
    float Damage = Spec.GetSetByCallerMagnitude(ComplyTags::DamageTypes::Damage_Physical);

    const FGameplayModifierEvaluatedData EvaluatedData(
    UComplyAttributeSet::GetIncomingDamageAttribute(), 
    EGameplayModOp::Additive, Damage);
    OutExecutionOutput.AddOutputModifier(EvaluatedData);
}

After the ExecCalc modifies the attribute, PostGameplayEffectExecute will get called, and it will see our meta attribute was modified. It also handles clamping so we don't have to worry about caveat 3.

Conclusion

The meta attribute and execution pipeline is a great way to handle damage in games that require more complex setup. Now that the core system is in place, my follow-up posts will get into capturing attributes and using those values in the calculation.

If you have any questions or feedback, feel free to contact me on LinkedIn, or email me: petric.marko04@gmail.com