Lyra Starter Game - Damage Scaling / Reduction

Hey all, I hope this is the right place to post this.
I’ve been diving into the Lyra project over the past week and watched both of Epic’s videos/streams on it.

At current, I’m trying to add conditional damage reduction, i.e. reduced friendly-fire damage, or shields (such as 80% damage reduction while armor is > 1, like in Half-Life 2).

However, I could so far only find the GCNL_Character_DamageTaken blueprint even related to damage events. Everything else is just gameplay events and the Gameplay Cue GameplayCue.Character.DamageTaken, which doesn’t exactly allow me to hook into the damage system to scale damage before it actually effects health.

I have not sifted through the C++ source yet, as I’m primarily an artist, not a programmer.

If you have any information that could point me in the right direction, that’d be greatly appreciated.

1 Like

Hi Darken217,
Unfortunately with Lyra, the damage calculation is handled in C++ via the class ULyraDamageExecution, via the function void ULyraDamageExecution::Execute_Implementation. This Damage Execution is used, for example, inside of the Gameplay Effect GameplayEffectParent_Damage_Basic, as shown below:

There is a good resource on Github, with an example project, where you can see how damage calculation can be done: GitHub - tranek/GASDocumentation: My understanding of Unreal Engine 4's GameplayAbilitySystem plugin with a simple multiplayer sample project.

You will need to update this function, or create a brand new execution calculation deriving from UGameplayEffectExecutionCalculation; this can be in C++ or in Blueprints, as shown below:

You just need to override the Execute function and capture the relevant attributes. I hope this information helps, and best of luck.

void ULyraDamageExecution::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams, FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
	const FGameplayEffectSpec& Spec = ExecutionParams.GetOwningSpec();
	FLyraGameplayEffectContext* TypedContext = FLyraGameplayEffectContext::ExtractEffectContext(Spec.GetContext());

	const FGameplayTagContainer* SourceTags = Spec.CapturedSourceTags.GetAggregatedTags();
	const FGameplayTagContainer* TargetTags = Spec.CapturedTargetTags.GetAggregatedTags();

	FAggregatorEvaluateParameters EvaluateParameters;
	EvaluateParameters.SourceTags = SourceTags;
	EvaluateParameters.TargetTags = TargetTags;

	float CurrentHealth = 0.0f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().HealthDef, EvaluateParameters, CurrentHealth);

	float BaseDamage = 0.0f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().BaseDamageDef, EvaluateParameters, BaseDamage);

	const AActor* EffectCauser = TypedContext->GetEffectCauser();
	const FHitResult* HitActorResult = TypedContext->GetHitResult();

	AActor* HitActor = nullptr;
	FVector ImpactLocation = FVector::ZeroVector;
	FVector ImpactNormal = FVector::ZeroVector;
	FVector StartTrace = FVector::ZeroVector;
	FVector EndTrace = FVector::ZeroVector;

	// Calculation of hit actor, surface, zone, and distance all rely on whether the calculation has a hit result or not.
	// Effects just being added directly w/o having been targeted will always come in without a hit result, which must default
	// to some fallback information.
	if (HitActorResult)
		const FHitResult& CurHitResult = *HitActorResult;
		HitActor = CurHitResult.HitObjectHandle.FetchActor();
		if (HitActor)
			ImpactLocation = CurHitResult.ImpactPoint;
			ImpactNormal = CurHitResult.ImpactNormal;
			StartTrace = CurHitResult.TraceStart;
			EndTrace = CurHitResult.TraceEnd;

	// Handle case of no hit result or hit result not actually returning an actor
	UAbilitySystemComponent* TargetAbilitySystemComponent = ExecutionParams.GetTargetAbilitySystemComponent();
	if (!HitActor)
		HitActor = TargetAbilitySystemComponent ? TargetAbilitySystemComponent->GetAvatarActor_Direct() : nullptr;
		if (HitActor)
			ImpactLocation = HitActor->GetActorLocation();

	// Apply rules for team damage/self damage/etc...
	float DamageInteractionAllowedMultiplier = 0.0f;
	if (HitActor)
		ULyraTeamSubsystem* TeamSubsystem = HitActor->GetWorld()->GetSubsystem<ULyraTeamSubsystem>();
		DamageInteractionAllowedMultiplier = TeamSubsystem->CanCauseDamage(EffectCauser, HitActor) ? 1.0 : 0.0;

	// Determine distance
	float Distance = WORLD_MAX;

	if (TypedContext->HasOrigin())
		Distance = FVector::Dist(TypedContext->GetOrigin(), ImpactLocation);
	else if (EffectCauser)
		Distance = FVector::Dist(EffectCauser->GetActorLocation(), ImpactLocation);
		ensureMsgf(false, TEXT("Damage Calculation cannot deduce a source location for damage coming from %s; Falling back to WORLD_MAX dist!"), *GetPathNameSafe(Spec.Def));

	// Apply ability source modifiers
	float PhysicalMaterialAttenuation = 1.0f;
	float DistanceAttenuation = 1.0f;
	if (const ILyraAbilitySourceInterface* AbilitySource = TypedContext->GetAbilitySource())
		if (const UPhysicalMaterial* PhysMat = TypedContext->GetPhysicalMaterial())
			PhysicalMaterialAttenuation = AbilitySource->GetPhysicalMaterialAttenuation(PhysMat, SourceTags, TargetTags);

		DistanceAttenuation = AbilitySource->GetDistanceAttenuation(Distance, SourceTags, TargetTags);
	DistanceAttenuation = FMath::Max(DistanceAttenuation, 0.0f);

	// This clamp prevents us from doing more damage than there is health available.
	const float DamageDone = FMath::Clamp(BaseDamage * DistanceAttenuation * PhysicalMaterialAttenuation * DamageInteractionAllowedMultiplier, 0.0f, CurrentHealth);

	if (DamageDone > 0.0f)
		OutExecutionOutput.AddOutputModifier(FGameplayModifierEvaluatedData(ULyraHealthSet::GetHealthAttribute(), EGameplayModOp::Additive, -DamageDone));
#endif // #if WITH_SERVER_CODE

Thanks a lot. That’s a lot of good resources. I’ll dive into that as soon as I can.