Add files using upload-large-folder tool

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilitySet.cpp

@@ -0,0 +1,148 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraAbilitySet.h"
+
+#include "AbilitySystem/Abilities/LyraGameplayAbility.h"
+#include "LyraAbilitySystemComponent.h"
+#include "LyraLogChannels.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraAbilitySet)
+
+void FLyraAbilitySet_GrantedHandles::AddAbilitySpecHandle(const FGameplayAbilitySpecHandle& Handle)
+{
+	if (Handle.IsValid())
+	{
+		AbilitySpecHandles.Add(Handle);
+	}
+}
+
+void FLyraAbilitySet_GrantedHandles::AddGameplayEffectHandle(const FActiveGameplayEffectHandle& Handle)
+{
+	if (Handle.IsValid())
+	{
+		GameplayEffectHandles.Add(Handle);
+	}
+}
+
+void FLyraAbilitySet_GrantedHandles::AddAttributeSet(UAttributeSet* Set)
+{
+	GrantedAttributeSets.Add(Set);
+}
+
+void FLyraAbilitySet_GrantedHandles::TakeFromAbilitySystem(ULyraAbilitySystemComponent* LyraASC)
+{
+	check(LyraASC);
+
+	if (!LyraASC->IsOwnerActorAuthoritative())
+	{
+		// Must be authoritative to give or take ability sets.
+		return;
+	}
+
+	for (const FGameplayAbilitySpecHandle& Handle : AbilitySpecHandles)
+	{
+		if (Handle.IsValid())
+		{
+			LyraASC->ClearAbility(Handle);
+		}
+	}
+
+	for (const FActiveGameplayEffectHandle& Handle : GameplayEffectHandles)
+	{
+		if (Handle.IsValid())
+		{
+			LyraASC->RemoveActiveGameplayEffect(Handle);
+		}
+	}
+
+	for (UAttributeSet* Set : GrantedAttributeSets)
+	{
+		LyraASC->RemoveSpawnedAttribute(Set);
+	}
+
+	AbilitySpecHandles.Reset();
+	GameplayEffectHandles.Reset();
+	GrantedAttributeSets.Reset();
+}
+
+ULyraAbilitySet::ULyraAbilitySet(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+void ULyraAbilitySet::GiveToAbilitySystem(ULyraAbilitySystemComponent* LyraASC, FLyraAbilitySet_GrantedHandles* OutGrantedHandles, UObject* SourceObject) const
+{
+	check(LyraASC);
+
+	if (!LyraASC->IsOwnerActorAuthoritative())
+	{
+		// Must be authoritative to give or take ability sets.
+		return;
+	}
+	
+	// Grant the attribute sets.
+	for (int32 SetIndex = 0; SetIndex < GrantedAttributes.Num(); ++SetIndex)
+	{
+		const FLyraAbilitySet_AttributeSet& SetToGrant = GrantedAttributes[SetIndex];
+
+		if (!IsValid(SetToGrant.AttributeSet))
+		{
+			UE_LOG(LogLyraAbilitySystem, Error, TEXT("GrantedAttributes[%d] on ability set [%s] is not valid"), SetIndex, *GetNameSafe(this));
+			continue;
+		}
+
+		UAttributeSet* NewSet = NewObject<UAttributeSet>(LyraASC->GetOwner(), SetToGrant.AttributeSet);
+		LyraASC->AddAttributeSetSubobject(NewSet);
+
+		if (OutGrantedHandles)
+		{
+			OutGrantedHandles->AddAttributeSet(NewSet);
+		}
+	}
+
+	// Grant the gameplay abilities.
+	for (int32 AbilityIndex = 0; AbilityIndex < GrantedGameplayAbilities.Num(); ++AbilityIndex)
+	{
+		const FLyraAbilitySet_GameplayAbility& AbilityToGrant = GrantedGameplayAbilities[AbilityIndex];
+
+		if (!IsValid(AbilityToGrant.Ability))
+		{
+			UE_LOG(LogLyraAbilitySystem, Error, TEXT("GrantedGameplayAbilities[%d] on ability set [%s] is not valid."), AbilityIndex, *GetNameSafe(this));
+			continue;
+		}
+
+		ULyraGameplayAbility* AbilityCDO = AbilityToGrant.Ability->GetDefaultObject<ULyraGameplayAbility>();
+
+		FGameplayAbilitySpec AbilitySpec(AbilityCDO, AbilityToGrant.AbilityLevel);
+		AbilitySpec.SourceObject = SourceObject;
+		AbilitySpec.GetDynamicSpecSourceTags().AddTag(AbilityToGrant.InputTag);
+
+		const FGameplayAbilitySpecHandle AbilitySpecHandle = LyraASC->GiveAbility(AbilitySpec);
+
+		if (OutGrantedHandles)
+		{
+			OutGrantedHandles->AddAbilitySpecHandle(AbilitySpecHandle);
+		}
+	}
+
+	// Grant the gameplay effects.
+	for (int32 EffectIndex = 0; EffectIndex < GrantedGameplayEffects.Num(); ++EffectIndex)
+	{
+		const FLyraAbilitySet_GameplayEffect& EffectToGrant = GrantedGameplayEffects[EffectIndex];
+
+		if (!IsValid(EffectToGrant.GameplayEffect))
+		{
+			UE_LOG(LogLyraAbilitySystem, Error, TEXT("GrantedGameplayEffects[%d] on ability set [%s] is not valid"), EffectIndex, *GetNameSafe(this));
+			continue;
+		}
+
+		const UGameplayEffect* GameplayEffect = EffectToGrant.GameplayEffect->GetDefaultObject<UGameplayEffect>();
+		const FActiveGameplayEffectHandle GameplayEffectHandle = LyraASC->ApplyGameplayEffectToSelf(GameplayEffect, EffectToGrant.EffectLevel, LyraASC->MakeEffectContext());
+
+		if (OutGrantedHandles)
+		{
+			OutGrantedHandles->AddGameplayEffectHandle(GameplayEffectHandle);
+		}
+	}
+}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilitySet.h

@@ -0,0 +1,149 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "ActiveGameplayEffectHandle.h"
+#include "Engine/DataAsset.h"
+#include "AttributeSet.h"
+#include "GameplayTagContainer.h"
+
+#include "GameplayAbilitySpecHandle.h"
+#include "LyraAbilitySet.generated.h"
+
+class UAttributeSet;
+class UGameplayEffect;
+class ULyraAbilitySystemComponent;
+class ULyraGameplayAbility;
+class UObject;
+
+
+/**
+ * FLyraAbilitySet_GameplayAbility
+ *
+ *	Data used by the ability set to grant gameplay abilities.
+ */
+USTRUCT(BlueprintType)
+struct FLyraAbilitySet_GameplayAbility
+{
+	GENERATED_BODY()
+
+public:
+
+	// Gameplay ability to grant.
+	UPROPERTY(EditDefaultsOnly)
+	TSubclassOf<ULyraGameplayAbility> Ability = nullptr;
+
+	// Level of ability to grant.
+	UPROPERTY(EditDefaultsOnly)
+	int32 AbilityLevel = 1;
+
+	// Tag used to process input for the ability.
+	UPROPERTY(EditDefaultsOnly, Meta = (Categories = "InputTag"))
+	FGameplayTag InputTag;
+};
+
+
+/**
+ * FLyraAbilitySet_GameplayEffect
+ *
+ *	Data used by the ability set to grant gameplay effects.
+ */
+USTRUCT(BlueprintType)
+struct FLyraAbilitySet_GameplayEffect
+{
+	GENERATED_BODY()
+
+public:
+
+	// Gameplay effect to grant.
+	UPROPERTY(EditDefaultsOnly)
+	TSubclassOf<UGameplayEffect> GameplayEffect = nullptr;
+
+	// Level of gameplay effect to grant.
+	UPROPERTY(EditDefaultsOnly)
+	float EffectLevel = 1.0f;
+};
+
+/**
+ * FLyraAbilitySet_AttributeSet
+ *
+ *	Data used by the ability set to grant attribute sets.
+ */
+USTRUCT(BlueprintType)
+struct FLyraAbilitySet_AttributeSet
+{
+	GENERATED_BODY()
+
+public:
+	// Gameplay effect to grant.
+	UPROPERTY(EditDefaultsOnly)
+	TSubclassOf<UAttributeSet> AttributeSet;
+
+};
+
+/**
+ * FLyraAbilitySet_GrantedHandles
+ *
+ *	Data used to store handles to what has been granted by the ability set.
+ */
+USTRUCT(BlueprintType)
+struct FLyraAbilitySet_GrantedHandles
+{
+	GENERATED_BODY()
+
+public:
+
+	void AddAbilitySpecHandle(const FGameplayAbilitySpecHandle& Handle);
+	void AddGameplayEffectHandle(const FActiveGameplayEffectHandle& Handle);
+	void AddAttributeSet(UAttributeSet* Set);
+
+	void TakeFromAbilitySystem(ULyraAbilitySystemComponent* LyraASC);
+
+protected:
+
+	// Handles to the granted abilities.
+	UPROPERTY()
+	TArray<FGameplayAbilitySpecHandle> AbilitySpecHandles;
+
+	// Handles to the granted gameplay effects.
+	UPROPERTY()
+	TArray<FActiveGameplayEffectHandle> GameplayEffectHandles;
+
+	// Pointers to the granted attribute sets
+	UPROPERTY()
+	TArray<TObjectPtr<UAttributeSet>> GrantedAttributeSets;
+};
+
+
+/**
+ * ULyraAbilitySet
+ *
+ *	Non-mutable data asset used to grant gameplay abilities and gameplay effects.
+ */
+UCLASS(BlueprintType, Const)
+class ULyraAbilitySet : public UPrimaryDataAsset
+{
+	GENERATED_BODY()
+
+public:
+
+	ULyraAbilitySet(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
+
+	// Grants the ability set to the specified ability system component.
+	// The returned handles can be used later to take away anything that was granted.
+	void GiveToAbilitySystem(ULyraAbilitySystemComponent* LyraASC, FLyraAbilitySet_GrantedHandles* OutGrantedHandles, UObject* SourceObject = nullptr) const;
+
+protected:
+
+	// Gameplay abilities to grant when this ability set is granted.
+	UPROPERTY(EditDefaultsOnly, Category = "Gameplay Abilities", meta=(TitleProperty=Ability))
+	TArray<FLyraAbilitySet_GameplayAbility> GrantedGameplayAbilities;
+
+	// Gameplay effects to grant when this ability set is granted.
+	UPROPERTY(EditDefaultsOnly, Category = "Gameplay Effects", meta=(TitleProperty=GameplayEffect))
+	TArray<FLyraAbilitySet_GameplayEffect> GrantedGameplayEffects;
+
+	// Attribute sets to grant when this ability set is granted.
+	UPROPERTY(EditDefaultsOnly, Category = "Attribute Sets", meta=(TitleProperty=AttributeSet))
+	TArray<FLyraAbilitySet_AttributeSet> GrantedAttributes;
+};

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilitySourceInterface.cpp

@@ -0,0 +1,10 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraAbilitySourceInterface.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraAbilitySourceInterface)
+
+ULyraAbilitySourceInterface::ULyraAbilitySourceInterface(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilitySourceInterface.h

@@ -0,0 +1,36 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "UObject/Interface.h"
+
+#include "LyraAbilitySourceInterface.generated.h"
+
+class UObject;
+class UPhysicalMaterial;
+struct FGameplayTagContainer;
+
+/** Base interface for anything acting as a ability calculation source */
+UINTERFACE()
+class ULyraAbilitySourceInterface : public UInterface
+{
+	GENERATED_UINTERFACE_BODY()
+};
+
+class ILyraAbilitySourceInterface
+{
+	GENERATED_IINTERFACE_BODY()
+
+	/**
+	 * Compute the multiplier for effect falloff with distance
+	 * 
+	 * @param Distance			Distance from source to target for ability calculations (distance bullet traveled for a gun, etc...)
+	 * @param SourceTags		Aggregated Tags from the source
+	 * @param TargetTags		Aggregated Tags currently on the target
+	 * 
+	 * @return Multiplier to apply to the base attribute value due to distance
+	 */
+	virtual float GetDistanceAttenuation(float Distance, const FGameplayTagContainer* SourceTags = nullptr, const FGameplayTagContainer* TargetTags = nullptr) const = 0;
+
+	virtual float GetPhysicalMaterialAttenuation(const UPhysicalMaterial* PhysicalMaterial, const FGameplayTagContainer* SourceTags = nullptr, const FGameplayTagContainer* TargetTags = nullptr) const = 0;
+};

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilitySystemComponent.cpp

@@ -0,0 +1,528 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraAbilitySystemComponent.h"
+
+#include "AbilitySystem/Abilities/LyraGameplayAbility.h"
+#include "AbilitySystem/LyraAbilityTagRelationshipMapping.h"
+#include "Animation/LyraAnimInstance.h"
+#include "Engine/World.h"
+#include "GameFramework/Pawn.h"
+#include "LyraGlobalAbilitySystem.h"
+#include "LyraLogChannels.h"
+#include "System/LyraAssetManager.h"
+#include "System/LyraGameData.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraAbilitySystemComponent)
+
+UE_DEFINE_GAMEPLAY_TAG(TAG_Gameplay_AbilityInputBlocked, "Gameplay.AbilityInputBlocked");
+
+ULyraAbilitySystemComponent::ULyraAbilitySystemComponent(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+	InputPressedSpecHandles.Reset();
+	InputReleasedSpecHandles.Reset();
+	InputHeldSpecHandles.Reset();
+
+	FMemory::Memset(ActivationGroupCounts, 0, sizeof(ActivationGroupCounts));
+}
+
+void ULyraAbilitySystemComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	if (ULyraGlobalAbilitySystem* GlobalAbilitySystem = UWorld::GetSubsystem<ULyraGlobalAbilitySystem>(GetWorld()))
+	{
+		GlobalAbilitySystem->UnregisterASC(this);
+	}
+
+	Super::EndPlay(EndPlayReason);
+}
+
+void ULyraAbilitySystemComponent::InitAbilityActorInfo(AActor* InOwnerActor, AActor* InAvatarActor)
+{
+	FGameplayAbilityActorInfo* ActorInfo = AbilityActorInfo.Get();
+	check(ActorInfo);
+	check(InOwnerActor);
+
+	const bool bHasNewPawnAvatar = Cast<APawn>(InAvatarActor) && (InAvatarActor != ActorInfo->AvatarActor);
+
+	Super::InitAbilityActorInfo(InOwnerActor, InAvatarActor);
+
+	if (bHasNewPawnAvatar)
+	{
+		// Notify all abilities that a new pawn avatar has been set
+		for (const FGameplayAbilitySpec& AbilitySpec : ActivatableAbilities.Items)
+		{
+PRAGMA_DISABLE_DEPRECATION_WARNINGS
+			ensureMsgf(AbilitySpec.Ability && AbilitySpec.Ability->GetInstancingPolicy() != EGameplayAbilityInstancingPolicy::NonInstanced, TEXT("InitAbilityActorInfo: All Abilities should be Instanced (NonInstanced is being deprecated due to usability issues)."));
+PRAGMA_ENABLE_DEPRECATION_WARNINGS
+	
+			TArray<UGameplayAbility*> Instances = AbilitySpec.GetAbilityInstances();
+			for (UGameplayAbility* AbilityInstance : Instances)
+			{
+				ULyraGameplayAbility* LyraAbilityInstance = Cast<ULyraGameplayAbility>(AbilityInstance);
+				if (LyraAbilityInstance)
+				{
+					// Ability instances may be missing for replays
+					LyraAbilityInstance->OnPawnAvatarSet();
+				}
+			}
+		}
+
+		// Register with the global system once we actually have a pawn avatar. We wait until this time since some globally-applied effects may require an avatar.
+		if (ULyraGlobalAbilitySystem* GlobalAbilitySystem = UWorld::GetSubsystem<ULyraGlobalAbilitySystem>(GetWorld()))
+		{
+			GlobalAbilitySystem->RegisterASC(this);
+		}
+
+		if (ULyraAnimInstance* LyraAnimInst = Cast<ULyraAnimInstance>(ActorInfo->GetAnimInstance()))
+		{
+			LyraAnimInst->InitializeWithAbilitySystem(this);
+		}
+
+		TryActivateAbilitiesOnSpawn();
+	}
+}
+
+void ULyraAbilitySystemComponent::TryActivateAbilitiesOnSpawn()
+{
+	ABILITYLIST_SCOPE_LOCK();
+	for (const FGameplayAbilitySpec& AbilitySpec : ActivatableAbilities.Items)
+	{
+		if (const ULyraGameplayAbility* LyraAbilityCDO = Cast<ULyraGameplayAbility>(AbilitySpec.Ability))
+		{
+			LyraAbilityCDO->TryActivateAbilityOnSpawn(AbilityActorInfo.Get(), AbilitySpec);
+		}
+	}
+}
+
+void ULyraAbilitySystemComponent::CancelAbilitiesByFunc(TShouldCancelAbilityFunc ShouldCancelFunc, bool bReplicateCancelAbility)
+{
+	ABILITYLIST_SCOPE_LOCK();
+	for (const FGameplayAbilitySpec& AbilitySpec : ActivatableAbilities.Items)
+	{
+		if (!AbilitySpec.IsActive())
+		{
+			continue;
+		}
+
+		ULyraGameplayAbility* LyraAbilityCDO = Cast<ULyraGameplayAbility>(AbilitySpec.Ability);
+		if (!LyraAbilityCDO)
+		{
+			UE_LOG(LogLyraAbilitySystem, Error, TEXT("CancelAbilitiesByFunc: Non-LyraGameplayAbility %s was Granted to ASC. Skipping."), *AbilitySpec.Ability.GetName());
+			continue;
+		}
+
+PRAGMA_DISABLE_DEPRECATION_WARNINGS
+		ensureMsgf(AbilitySpec.Ability->GetInstancingPolicy() != EGameplayAbilityInstancingPolicy::NonInstanced, TEXT("CancelAbilitiesByFunc: All Abilities should be Instanced (NonInstanced is being deprecated due to usability issues)."));
+PRAGMA_ENABLE_DEPRECATION_WARNINGS
+			
+		// Cancel all the spawned instances.
+		TArray<UGameplayAbility*> Instances = AbilitySpec.GetAbilityInstances();
+		for (UGameplayAbility* AbilityInstance : Instances)
+		{
+			ULyraGameplayAbility* LyraAbilityInstance = CastChecked<ULyraGameplayAbility>(AbilityInstance);
+
+			if (ShouldCancelFunc(LyraAbilityInstance, AbilitySpec.Handle))
+			{
+				if (LyraAbilityInstance->CanBeCanceled())
+				{
+					LyraAbilityInstance->CancelAbility(AbilitySpec.Handle, AbilityActorInfo.Get(), LyraAbilityInstance->GetCurrentActivationInfo(), bReplicateCancelAbility);
+				}
+				else
+				{
+					UE_LOG(LogLyraAbilitySystem, Error, TEXT("CancelAbilitiesByFunc: Can't cancel ability [%s] because CanBeCanceled is false."), *LyraAbilityInstance->GetName());
+				}
+			}
+		}
+	}
+}
+
+void ULyraAbilitySystemComponent::CancelInputActivatedAbilities(bool bReplicateCancelAbility)
+{
+	auto ShouldCancelFunc = [this](const ULyraGameplayAbility* LyraAbility, FGameplayAbilitySpecHandle Handle)
+	{
+		const ELyraAbilityActivationPolicy ActivationPolicy = LyraAbility->GetActivationPolicy();
+		return ((ActivationPolicy == ELyraAbilityActivationPolicy::OnInputTriggered) || (ActivationPolicy == ELyraAbilityActivationPolicy::WhileInputActive));
+	};
+
+	CancelAbilitiesByFunc(ShouldCancelFunc, bReplicateCancelAbility);
+}
+
+void ULyraAbilitySystemComponent::AbilitySpecInputPressed(FGameplayAbilitySpec& Spec)
+{
+	Super::AbilitySpecInputPressed(Spec);
+
+	// We don't support UGameplayAbility::bReplicateInputDirectly.
+	// Use replicated events instead so that the WaitInputPress ability task works.
+	if (Spec.IsActive())
+	{
+PRAGMA_DISABLE_DEPRECATION_WARNINGS
+		const UGameplayAbility* Instance = Spec.GetPrimaryInstance();
+		FPredictionKey OriginalPredictionKey = Instance ? Instance->GetCurrentActivationInfo().GetActivationPredictionKey() : Spec.ActivationInfo.GetActivationPredictionKey();
+PRAGMA_ENABLE_DEPRECATION_WARNINGS
+
+		// Invoke the InputPressed event. This is not replicated here. If someone is listening, they may replicate the InputPressed event to the server.
+		InvokeReplicatedEvent(EAbilityGenericReplicatedEvent::InputPressed, Spec.Handle, OriginalPredictionKey);
+	}
+}
+
+void ULyraAbilitySystemComponent::AbilitySpecInputReleased(FGameplayAbilitySpec& Spec)
+{
+	Super::AbilitySpecInputReleased(Spec);
+
+	// We don't support UGameplayAbility::bReplicateInputDirectly.
+	// Use replicated events instead so that the WaitInputRelease ability task works.
+	if (Spec.IsActive())
+	{
+PRAGMA_DISABLE_DEPRECATION_WARNINGS
+		const UGameplayAbility* Instance = Spec.GetPrimaryInstance();
+		FPredictionKey OriginalPredictionKey = Instance ? Instance->GetCurrentActivationInfo().GetActivationPredictionKey() : Spec.ActivationInfo.GetActivationPredictionKey();
+PRAGMA_ENABLE_DEPRECATION_WARNINGS
+
+		// Invoke the InputReleased event. This is not replicated here. If someone is listening, they may replicate the InputReleased event to the server.
+		InvokeReplicatedEvent(EAbilityGenericReplicatedEvent::InputReleased, Spec.Handle, OriginalPredictionKey);
+	}
+}
+
+void ULyraAbilitySystemComponent::AbilityInputTagPressed(const FGameplayTag& InputTag)
+{
+	if (InputTag.IsValid())
+	{
+		for (const FGameplayAbilitySpec& AbilitySpec : ActivatableAbilities.Items)
+		{
+			if (AbilitySpec.Ability && (AbilitySpec.GetDynamicSpecSourceTags().HasTagExact(InputTag)))
+			{
+				InputPressedSpecHandles.AddUnique(AbilitySpec.Handle);
+				InputHeldSpecHandles.AddUnique(AbilitySpec.Handle);
+			}
+		}
+	}
+}
+
+void ULyraAbilitySystemComponent::AbilityInputTagReleased(const FGameplayTag& InputTag)
+{
+	if (InputTag.IsValid())
+	{
+		for (const FGameplayAbilitySpec& AbilitySpec : ActivatableAbilities.Items)
+		{
+			if (AbilitySpec.Ability && (AbilitySpec.GetDynamicSpecSourceTags().HasTagExact(InputTag)))
+			{
+				InputReleasedSpecHandles.AddUnique(AbilitySpec.Handle);
+				InputHeldSpecHandles.Remove(AbilitySpec.Handle);
+			}
+		}
+	}
+}
+
+void ULyraAbilitySystemComponent::ProcessAbilityInput(float DeltaTime, bool bGamePaused)
+{
+	if (HasMatchingGameplayTag(TAG_Gameplay_AbilityInputBlocked))
+	{
+		ClearAbilityInput();
+		return;
+	}
+
+	static TArray<FGameplayAbilitySpecHandle> AbilitiesToActivate;
+	AbilitiesToActivate.Reset();
+
+	//@TODO: See if we can use FScopedServerAbilityRPCBatcher ScopedRPCBatcher in some of these loops
+
+	//
+	// Process all abilities that activate when the input is held.
+	//
+	for (const FGameplayAbilitySpecHandle& SpecHandle : InputHeldSpecHandles)
+	{
+		if (const FGameplayAbilitySpec* AbilitySpec = FindAbilitySpecFromHandle(SpecHandle))
+		{
+			if (AbilitySpec->Ability && !AbilitySpec->IsActive())
+			{
+				const ULyraGameplayAbility* LyraAbilityCDO = Cast<ULyraGameplayAbility>(AbilitySpec->Ability);
+				if (LyraAbilityCDO && LyraAbilityCDO->GetActivationPolicy() == ELyraAbilityActivationPolicy::WhileInputActive)
+				{
+					AbilitiesToActivate.AddUnique(AbilitySpec->Handle);
+				}
+			}
+		}
+	}
+
+	//
+	// Process all abilities that had their input pressed this frame.
+	//
+	for (const FGameplayAbilitySpecHandle& SpecHandle : InputPressedSpecHandles)
+	{
+		if (FGameplayAbilitySpec* AbilitySpec = FindAbilitySpecFromHandle(SpecHandle))
+		{
+			if (AbilitySpec->Ability)
+			{
+				AbilitySpec->InputPressed = true;
+
+				if (AbilitySpec->IsActive())
+				{
+					// Ability is active so pass along the input event.
+					AbilitySpecInputPressed(*AbilitySpec);
+				}
+				else
+				{
+					const ULyraGameplayAbility* LyraAbilityCDO = Cast<ULyraGameplayAbility>(AbilitySpec->Ability);
+
+					if (LyraAbilityCDO && LyraAbilityCDO->GetActivationPolicy() == ELyraAbilityActivationPolicy::OnInputTriggered)
+					{
+						AbilitiesToActivate.AddUnique(AbilitySpec->Handle);
+					}
+				}
+			}
+		}
+	}
+
+	//
+	// Try to activate all the abilities that are from presses and holds.
+	// We do it all at once so that held inputs don't activate the ability
+	// and then also send a input event to the ability because of the press.
+	//
+	for (const FGameplayAbilitySpecHandle& AbilitySpecHandle : AbilitiesToActivate)
+	{
+		TryActivateAbility(AbilitySpecHandle);
+	}
+
+	//
+	// Process all abilities that had their input released this frame.
+	//
+	for (const FGameplayAbilitySpecHandle& SpecHandle : InputReleasedSpecHandles)
+	{
+		if (FGameplayAbilitySpec* AbilitySpec = FindAbilitySpecFromHandle(SpecHandle))
+		{
+			if (AbilitySpec->Ability)
+			{
+				AbilitySpec->InputPressed = false;
+
+				if (AbilitySpec->IsActive())
+				{
+					// Ability is active so pass along the input event.
+					AbilitySpecInputReleased(*AbilitySpec);
+				}
+			}
+		}
+	}
+
+	//
+	// Clear the cached ability handles.
+	//
+	InputPressedSpecHandles.Reset();
+	InputReleasedSpecHandles.Reset();
+}
+
+void ULyraAbilitySystemComponent::ClearAbilityInput()
+{
+	InputPressedSpecHandles.Reset();
+	InputReleasedSpecHandles.Reset();
+	InputHeldSpecHandles.Reset();
+}
+
+void ULyraAbilitySystemComponent::NotifyAbilityActivated(const FGameplayAbilitySpecHandle Handle, UGameplayAbility* Ability)
+{
+	Super::NotifyAbilityActivated(Handle, Ability);
+
+	if (ULyraGameplayAbility* LyraAbility = Cast<ULyraGameplayAbility>(Ability))
+	{
+		AddAbilityToActivationGroup(LyraAbility->GetActivationGroup(), LyraAbility);
+	}
+}
+
+void ULyraAbilitySystemComponent::NotifyAbilityFailed(const FGameplayAbilitySpecHandle Handle, UGameplayAbility* Ability, const FGameplayTagContainer& FailureReason)
+{
+	Super::NotifyAbilityFailed(Handle, Ability, FailureReason);
+
+	if (APawn* Avatar = Cast<APawn>(GetAvatarActor()))
+	{
+		if (!Avatar->IsLocallyControlled() && Ability->IsSupportedForNetworking())
+		{
+			ClientNotifyAbilityFailed(Ability, FailureReason);
+			return;
+		}
+	}
+
+	HandleAbilityFailed(Ability, FailureReason);
+}
+
+void ULyraAbilitySystemComponent::NotifyAbilityEnded(FGameplayAbilitySpecHandle Handle, UGameplayAbility* Ability, bool bWasCancelled)
+{
+	Super::NotifyAbilityEnded(Handle, Ability, bWasCancelled);
+
+	if (ULyraGameplayAbility* LyraAbility = Cast<ULyraGameplayAbility>(Ability))
+	{
+		RemoveAbilityFromActivationGroup(LyraAbility->GetActivationGroup(), LyraAbility);
+	}
+}
+
+void ULyraAbilitySystemComponent::ApplyAbilityBlockAndCancelTags(const FGameplayTagContainer& AbilityTags, UGameplayAbility* RequestingAbility, bool bEnableBlockTags, const FGameplayTagContainer& BlockTags, bool bExecuteCancelTags, const FGameplayTagContainer& CancelTags)
+{
+	FGameplayTagContainer ModifiedBlockTags = BlockTags;
+	FGameplayTagContainer ModifiedCancelTags = CancelTags;
+
+	if (TagRelationshipMapping)
+	{
+		// Use the mapping to expand the ability tags into block and cancel tag
+		TagRelationshipMapping->GetAbilityTagsToBlockAndCancel(AbilityTags, &ModifiedBlockTags, &ModifiedCancelTags);
+	}
+
+	Super::ApplyAbilityBlockAndCancelTags(AbilityTags, RequestingAbility, bEnableBlockTags, ModifiedBlockTags, bExecuteCancelTags, ModifiedCancelTags);
+
+	//@TODO: Apply any special logic like blocking input or movement
+}
+
+void ULyraAbilitySystemComponent::HandleChangeAbilityCanBeCanceled(const FGameplayTagContainer& AbilityTags, UGameplayAbility* RequestingAbility, bool bCanBeCanceled)
+{
+	Super::HandleChangeAbilityCanBeCanceled(AbilityTags, RequestingAbility, bCanBeCanceled);
+
+	//@TODO: Apply any special logic like blocking input or movement
+}
+
+void ULyraAbilitySystemComponent::GetAdditionalActivationTagRequirements(const FGameplayTagContainer& AbilityTags, FGameplayTagContainer& OutActivationRequired, FGameplayTagContainer& OutActivationBlocked) const
+{
+	if (TagRelationshipMapping)
+	{
+		TagRelationshipMapping->GetRequiredAndBlockedActivationTags(AbilityTags, &OutActivationRequired, &OutActivationBlocked);
+	}
+}
+
+void ULyraAbilitySystemComponent::SetTagRelationshipMapping(ULyraAbilityTagRelationshipMapping* NewMapping)
+{
+	TagRelationshipMapping = NewMapping;
+}
+
+void ULyraAbilitySystemComponent::ClientNotifyAbilityFailed_Implementation(const UGameplayAbility* Ability, const FGameplayTagContainer& FailureReason)
+{
+	HandleAbilityFailed(Ability, FailureReason);
+}
+
+void ULyraAbilitySystemComponent::HandleAbilityFailed(const UGameplayAbility* Ability, const FGameplayTagContainer& FailureReason)
+{
+	//UE_LOG(LogLyraAbilitySystem, Warning, TEXT("Ability %s failed to activate (tags: %s)"), *GetPathNameSafe(Ability), *FailureReason.ToString());
+
+	if (const ULyraGameplayAbility* LyraAbility = Cast<const ULyraGameplayAbility>(Ability))
+	{
+		LyraAbility->OnAbilityFailedToActivate(FailureReason);
+	}	
+}
+
+bool ULyraAbilitySystemComponent::IsActivationGroupBlocked(ELyraAbilityActivationGroup Group) const
+{
+	bool bBlocked = false;
+
+	switch (Group)
+	{
+	case ELyraAbilityActivationGroup::Independent:
+		// Independent abilities are never blocked.
+		bBlocked = false;
+		break;
+
+	case ELyraAbilityActivationGroup::Exclusive_Replaceable:
+	case ELyraAbilityActivationGroup::Exclusive_Blocking:
+		// Exclusive abilities can activate if nothing is blocking.
+		bBlocked = (ActivationGroupCounts[(uint8)ELyraAbilityActivationGroup::Exclusive_Blocking] > 0);
+		break;
+
+	default:
+		checkf(false, TEXT("IsActivationGroupBlocked: Invalid ActivationGroup [%d]\n"), (uint8)Group);
+		break;
+	}
+
+	return bBlocked;
+}
+
+void ULyraAbilitySystemComponent::AddAbilityToActivationGroup(ELyraAbilityActivationGroup Group, ULyraGameplayAbility* LyraAbility)
+{
+	check(LyraAbility);
+	check(ActivationGroupCounts[(uint8)Group] < INT32_MAX);
+
+	ActivationGroupCounts[(uint8)Group]++;
+
+	const bool bReplicateCancelAbility = false;
+
+	switch (Group)
+	{
+	case ELyraAbilityActivationGroup::Independent:
+		// Independent abilities do not cancel any other abilities.
+		break;
+
+	case ELyraAbilityActivationGroup::Exclusive_Replaceable:
+	case ELyraAbilityActivationGroup::Exclusive_Blocking:
+		CancelActivationGroupAbilities(ELyraAbilityActivationGroup::Exclusive_Replaceable, LyraAbility, bReplicateCancelAbility);
+		break;
+
+	default:
+		checkf(false, TEXT("AddAbilityToActivationGroup: Invalid ActivationGroup [%d]\n"), (uint8)Group);
+		break;
+	}
+
+	const int32 ExclusiveCount = ActivationGroupCounts[(uint8)ELyraAbilityActivationGroup::Exclusive_Replaceable] + ActivationGroupCounts[(uint8)ELyraAbilityActivationGroup::Exclusive_Blocking];
+	if (!ensure(ExclusiveCount <= 1))
+	{
+		UE_LOG(LogLyraAbilitySystem, Error, TEXT("AddAbilityToActivationGroup: Multiple exclusive abilities are running."));
+	}
+}
+
+void ULyraAbilitySystemComponent::RemoveAbilityFromActivationGroup(ELyraAbilityActivationGroup Group, ULyraGameplayAbility* LyraAbility)
+{
+	check(LyraAbility);
+	check(ActivationGroupCounts[(uint8)Group] > 0);
+
+	ActivationGroupCounts[(uint8)Group]--;
+}
+
+void ULyraAbilitySystemComponent::CancelActivationGroupAbilities(ELyraAbilityActivationGroup Group, ULyraGameplayAbility* IgnoreLyraAbility, bool bReplicateCancelAbility)
+{
+	auto ShouldCancelFunc = [this, Group, IgnoreLyraAbility](const ULyraGameplayAbility* LyraAbility, FGameplayAbilitySpecHandle Handle)
+	{
+		return ((LyraAbility->GetActivationGroup() == Group) && (LyraAbility != IgnoreLyraAbility));
+	};
+
+	CancelAbilitiesByFunc(ShouldCancelFunc, bReplicateCancelAbility);
+}
+
+void ULyraAbilitySystemComponent::AddDynamicTagGameplayEffect(const FGameplayTag& Tag)
+{
+	const TSubclassOf<UGameplayEffect> DynamicTagGE = ULyraAssetManager::GetSubclass(ULyraGameData::Get().DynamicTagGameplayEffect);
+	if (!DynamicTagGE)
+	{
+		UE_LOG(LogLyraAbilitySystem, Warning, TEXT("AddDynamicTagGameplayEffect: Unable to find DynamicTagGameplayEffect [%s]."), *ULyraGameData::Get().DynamicTagGameplayEffect.GetAssetName());
+		return;
+	}
+
+	const FGameplayEffectSpecHandle SpecHandle = MakeOutgoingSpec(DynamicTagGE, 1.0f, MakeEffectContext());
+	FGameplayEffectSpec* Spec = SpecHandle.Data.Get();
+
+	if (!Spec)
+	{
+		UE_LOG(LogLyraAbilitySystem, Warning, TEXT("AddDynamicTagGameplayEffect: Unable to make outgoing spec for [%s]."), *GetNameSafe(DynamicTagGE));
+		return;
+	}
+
+	Spec->DynamicGrantedTags.AddTag(Tag);
+
+	ApplyGameplayEffectSpecToSelf(*Spec);
+}
+
+void ULyraAbilitySystemComponent::RemoveDynamicTagGameplayEffect(const FGameplayTag& Tag)
+{
+	const TSubclassOf<UGameplayEffect> DynamicTagGE = ULyraAssetManager::GetSubclass(ULyraGameData::Get().DynamicTagGameplayEffect);
+	if (!DynamicTagGE)
+	{
+		UE_LOG(LogLyraAbilitySystem, Warning, TEXT("RemoveDynamicTagGameplayEffect: Unable to find gameplay effect [%s]."), *ULyraGameData::Get().DynamicTagGameplayEffect.GetAssetName());
+		return;
+	}
+
+	FGameplayEffectQuery Query = FGameplayEffectQuery::MakeQuery_MatchAnyOwningTags(FGameplayTagContainer(Tag));
+	Query.EffectDefinition = DynamicTagGE;
+
+	RemoveActiveEffects(Query);
+}
+
+void ULyraAbilitySystemComponent::GetAbilityTargetData(const FGameplayAbilitySpecHandle AbilityHandle, FGameplayAbilityActivationInfo ActivationInfo, FGameplayAbilityTargetDataHandle& OutTargetDataHandle)
+{
+	TSharedPtr<FAbilityReplicatedDataCache> ReplicatedData = AbilityTargetDataMap.Find(FGameplayAbilitySpecHandleAndPredictionKey(AbilityHandle, ActivationInfo.GetActivationPredictionKey()));
+	if (ReplicatedData.IsValid())
+	{
+		OutTargetDataHandle = ReplicatedData->TargetData;
+	}
+}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilitySystemComponent.h

@@ -0,0 +1,110 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Abilities/LyraGameplayAbility.h"
+#include "AbilitySystemComponent.h"
+#include "NativeGameplayTags.h"
+
+#include "LyraAbilitySystemComponent.generated.h"
+
+#define UE_API LYRAGAME_API
+
+class AActor;
+class UGameplayAbility;
+class ULyraAbilityTagRelationshipMapping;
+class UObject;
+struct FFrame;
+struct FGameplayAbilityTargetDataHandle;
+
+LYRAGAME_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Gameplay_AbilityInputBlocked);
+
+/**
+ * ULyraAbilitySystemComponent
+ *
+ *	Base ability system component class used by this project.
+ */
+UCLASS(MinimalAPI)
+class ULyraAbilitySystemComponent : public UAbilitySystemComponent
+{
+	GENERATED_BODY()
+
+public:
+
+	UE_API ULyraAbilitySystemComponent(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
+
+	//~UActorComponent interface
+	UE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+	//~End of UActorComponent interface
+
+	UE_API virtual void InitAbilityActorInfo(AActor* InOwnerActor, AActor* InAvatarActor) override;
+
+	typedef TFunctionRef<bool(const ULyraGameplayAbility* LyraAbility, FGameplayAbilitySpecHandle Handle)> TShouldCancelAbilityFunc;
+	UE_API void CancelAbilitiesByFunc(TShouldCancelAbilityFunc ShouldCancelFunc, bool bReplicateCancelAbility);
+
+	UE_API void CancelInputActivatedAbilities(bool bReplicateCancelAbility);
+
+	UE_API void AbilityInputTagPressed(const FGameplayTag& InputTag);
+	UE_API void AbilityInputTagReleased(const FGameplayTag& InputTag);
+
+	UE_API void ProcessAbilityInput(float DeltaTime, bool bGamePaused);
+	UE_API void ClearAbilityInput();
+
+	UE_API bool IsActivationGroupBlocked(ELyraAbilityActivationGroup Group) const;
+	UE_API void AddAbilityToActivationGroup(ELyraAbilityActivationGroup Group, ULyraGameplayAbility* LyraAbility);
+	UE_API void RemoveAbilityFromActivationGroup(ELyraAbilityActivationGroup Group, ULyraGameplayAbility* LyraAbility);
+	UE_API void CancelActivationGroupAbilities(ELyraAbilityActivationGroup Group, ULyraGameplayAbility* IgnoreLyraAbility, bool bReplicateCancelAbility);
+
+	// Uses a gameplay effect to add the specified dynamic granted tag.
+	UE_API void AddDynamicTagGameplayEffect(const FGameplayTag& Tag);
+
+	// Removes all active instances of the gameplay effect that was used to add the specified dynamic granted tag.
+	UE_API void RemoveDynamicTagGameplayEffect(const FGameplayTag& Tag);
+
+	/** Gets the ability target data associated with the given ability handle and activation info */
+	UE_API void GetAbilityTargetData(const FGameplayAbilitySpecHandle AbilityHandle, FGameplayAbilityActivationInfo ActivationInfo, FGameplayAbilityTargetDataHandle& OutTargetDataHandle);
+
+	/** Sets the current tag relationship mapping, if null it will clear it out */
+	UE_API void SetTagRelationshipMapping(ULyraAbilityTagRelationshipMapping* NewMapping);
+	
+	/** Looks at ability tags and gathers additional required and blocking tags */
+	UE_API void GetAdditionalActivationTagRequirements(const FGameplayTagContainer& AbilityTags, FGameplayTagContainer& OutActivationRequired, FGameplayTagContainer& OutActivationBlocked) const;
+
+	UE_API void TryActivateAbilitiesOnSpawn();
+
+protected:
+
+	UE_API virtual void AbilitySpecInputPressed(FGameplayAbilitySpec& Spec) override;
+	UE_API virtual void AbilitySpecInputReleased(FGameplayAbilitySpec& Spec) override;
+
+	UE_API virtual void NotifyAbilityActivated(const FGameplayAbilitySpecHandle Handle, UGameplayAbility* Ability) override;
+	UE_API virtual void NotifyAbilityFailed(const FGameplayAbilitySpecHandle Handle, UGameplayAbility* Ability, const FGameplayTagContainer& FailureReason) override;
+	UE_API virtual void NotifyAbilityEnded(FGameplayAbilitySpecHandle Handle, UGameplayAbility* Ability, bool bWasCancelled) override;
+	UE_API virtual void ApplyAbilityBlockAndCancelTags(const FGameplayTagContainer& AbilityTags, UGameplayAbility* RequestingAbility, bool bEnableBlockTags, const FGameplayTagContainer& BlockTags, bool bExecuteCancelTags, const FGameplayTagContainer& CancelTags) override;
+	UE_API virtual void HandleChangeAbilityCanBeCanceled(const FGameplayTagContainer& AbilityTags, UGameplayAbility* RequestingAbility, bool bCanBeCanceled) override;
+
+	/** Notify client that an ability failed to activate */
+	UFUNCTION(Client, Unreliable)
+	UE_API void ClientNotifyAbilityFailed(const UGameplayAbility* Ability, const FGameplayTagContainer& FailureReason);
+
+	UE_API void HandleAbilityFailed(const UGameplayAbility* Ability, const FGameplayTagContainer& FailureReason);
+protected:
+
+	// If set, this table is used to look up tag relationships for activate and cancel
+	UPROPERTY()
+	TObjectPtr<ULyraAbilityTagRelationshipMapping> TagRelationshipMapping;
+
+	// Handles to abilities that had their input pressed this frame.
+	TArray<FGameplayAbilitySpecHandle> InputPressedSpecHandles;
+
+	// Handles to abilities that had their input released this frame.
+	TArray<FGameplayAbilitySpecHandle> InputReleasedSpecHandles;
+
+	// Handles to abilities that have their input held.
+	TArray<FGameplayAbilitySpecHandle> InputHeldSpecHandles;
+
+	// Number of abilities running in each activation group.
+	int32 ActivationGroupCounts[(uint8)ELyraAbilityActivationGroup::MAX];
+};
+
+#undef UE_API

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilitySystemGlobals.cpp

@@ -0,0 +1,20 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraAbilitySystemGlobals.h"
+
+#include "LyraGameplayEffectContext.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraAbilitySystemGlobals)
+
+struct FGameplayEffectContext;
+
+ULyraAbilitySystemGlobals::ULyraAbilitySystemGlobals(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+FGameplayEffectContext* ULyraAbilitySystemGlobals::AllocGameplayEffectContext() const
+{
+	return new FLyraGameplayEffectContext();
+}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilitySystemGlobals.h

@@ -0,0 +1,20 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "AbilitySystemGlobals.h"
+
+#include "LyraAbilitySystemGlobals.generated.h"
+
+class UObject;
+struct FGameplayEffectContext;
+
+UCLASS(Config=Game)
+class ULyraAbilitySystemGlobals : public UAbilitySystemGlobals
+{
+	GENERATED_UCLASS_BODY()
+
+	//~UAbilitySystemGlobals interface
+	virtual FGameplayEffectContext* AllocGameplayEffectContext() const override;
+	//~End of UAbilitySystemGlobals interface
+};

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilityTagRelationshipMapping.cpp

@@ -0,0 +1,63 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "AbilitySystem/LyraAbilityTagRelationshipMapping.h"
+
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraAbilityTagRelationshipMapping)
+
+void ULyraAbilityTagRelationshipMapping::GetAbilityTagsToBlockAndCancel(const FGameplayTagContainer& AbilityTags, FGameplayTagContainer* OutTagsToBlock, FGameplayTagContainer* OutTagsToCancel) const
+{
+	// Simple iteration for now
+	for (int32 i = 0; i < AbilityTagRelationships.Num(); i++)
+	{
+		const FLyraAbilityTagRelationship& Tags = AbilityTagRelationships[i];
+		if (AbilityTags.HasTag(Tags.AbilityTag))
+		{
+			if (OutTagsToBlock)
+			{
+				OutTagsToBlock->AppendTags(Tags.AbilityTagsToBlock);
+			}
+			if (OutTagsToCancel)
+			{
+				OutTagsToCancel->AppendTags(Tags.AbilityTagsToCancel);
+			}
+		}
+	}
+}
+
+void ULyraAbilityTagRelationshipMapping::GetRequiredAndBlockedActivationTags(const FGameplayTagContainer& AbilityTags, FGameplayTagContainer* OutActivationRequired, FGameplayTagContainer* OutActivationBlocked) const
+{
+	// Simple iteration for now
+	for (int32 i = 0; i < AbilityTagRelationships.Num(); i++)
+	{
+		const FLyraAbilityTagRelationship& Tags = AbilityTagRelationships[i];
+		if (AbilityTags.HasTag(Tags.AbilityTag))
+		{
+			if (OutActivationRequired)
+			{
+				OutActivationRequired->AppendTags(Tags.ActivationRequiredTags);
+			}
+			if (OutActivationBlocked)
+			{
+				OutActivationBlocked->AppendTags(Tags.ActivationBlockedTags);
+			}
+		}
+	}
+}
+
+bool ULyraAbilityTagRelationshipMapping::IsAbilityCancelledByTag(const FGameplayTagContainer& AbilityTags, const FGameplayTag& ActionTag) const
+{
+	// Simple iteration for now
+	for (int32 i = 0; i < AbilityTagRelationships.Num(); i++)
+	{
+		const FLyraAbilityTagRelationship& Tags = AbilityTagRelationships[i];
+
+		if (Tags.AbilityTag == ActionTag && Tags.AbilityTagsToCancel.HasAny(AbilityTags))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraAbilityTagRelationshipMapping.h

@@ -0,0 +1,60 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Engine/DataAsset.h"
+#include "GameplayTagContainer.h"
+
+#include "LyraAbilityTagRelationshipMapping.generated.h"
+
+class UObject;
+
+/** Struct that defines the relationship between different ability tags */
+USTRUCT()
+struct FLyraAbilityTagRelationship
+{
+	GENERATED_BODY()
+
+	/** The tag that this container relationship is about. Single tag, but abilities can have multiple of these */
+	UPROPERTY(EditAnywhere, Category = Ability, meta = (Categories = "Gameplay.Action"))
+	FGameplayTag AbilityTag;
+
+	/** The other ability tags that will be blocked by any ability using this tag */
+	UPROPERTY(EditAnywhere, Category = Ability)
+	FGameplayTagContainer AbilityTagsToBlock;
+
+	/** The other ability tags that will be canceled by any ability using this tag */
+	UPROPERTY(EditAnywhere, Category = Ability)
+	FGameplayTagContainer AbilityTagsToCancel;
+
+	/** If an ability has the tag, this is implicitly added to the activation required tags of the ability */
+	UPROPERTY(EditAnywhere, Category = Ability)
+	FGameplayTagContainer ActivationRequiredTags;
+
+	/** If an ability has the tag, this is implicitly added to the activation blocked tags of the ability */
+	UPROPERTY(EditAnywhere, Category = Ability)
+	FGameplayTagContainer ActivationBlockedTags;
+};
+
+
+/** Mapping of how ability tags block or cancel other abilities */
+UCLASS()
+class ULyraAbilityTagRelationshipMapping : public UDataAsset
+{
+	GENERATED_BODY()
+
+private:
+	/** The list of relationships between different gameplay tags (which ones block or cancel others) */
+	UPROPERTY(EditAnywhere, Category = Ability, meta=(TitleProperty="AbilityTag"))
+	TArray<FLyraAbilityTagRelationship> AbilityTagRelationships;
+
+public:
+	/** Given a set of ability tags, parse the tag relationship and fill out tags to block and cancel */
+	void GetAbilityTagsToBlockAndCancel(const FGameplayTagContainer& AbilityTags, FGameplayTagContainer* OutTagsToBlock, FGameplayTagContainer* OutTagsToCancel) const;
+
+	/** Given a set of ability tags, add additional required and blocking tags */
+	void GetRequiredAndBlockedActivationTags(const FGameplayTagContainer& AbilityTags, FGameplayTagContainer* OutActivationRequired, FGameplayTagContainer* OutActivationBlocked) const;
+
+	/** Returns true if the specified ability tags are canceled by the passed in action tag */
+	bool IsAbilityCancelledByTag(const FGameplayTagContainer& AbilityTags, const FGameplayTag& ActionTag) const;
+};

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraGameplayAbilityTargetData_SingleTargetHit.cpp

@@ -0,0 +1,32 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraGameplayAbilityTargetData_SingleTargetHit.h"
+
+#include "LyraGameplayEffectContext.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraGameplayAbilityTargetData_SingleTargetHit)
+
+struct FGameplayEffectContextHandle;
+
+//////////////////////////////////////////////////////////////////////
+
+void FLyraGameplayAbilityTargetData_SingleTargetHit::AddTargetDataToContext(FGameplayEffectContextHandle& Context, bool bIncludeActorArray) const
+{
+	FGameplayAbilityTargetData_SingleTargetHit::AddTargetDataToContext(Context, bIncludeActorArray);
+
+	// Add game-specific data
+	if (FLyraGameplayEffectContext* TypedContext = FLyraGameplayEffectContext::ExtractEffectContext(Context))
+	{
+		TypedContext->CartridgeID = CartridgeID;
+	}
+}
+
+bool FLyraGameplayAbilityTargetData_SingleTargetHit::NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess)
+{
+	FGameplayAbilityTargetData_SingleTargetHit::NetSerialize(Ar, Map, bOutSuccess);
+
+	Ar << CartridgeID;
+
+	return true;
+}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraGameplayAbilityTargetData_SingleTargetHit.h

@@ -0,0 +1,45 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Abilities/GameplayAbilityTargetTypes.h"
+
+#include "LyraGameplayAbilityTargetData_SingleTargetHit.generated.h"
+
+class FArchive;
+struct FGameplayEffectContextHandle;
+
+
+/** Game-specific additions to SingleTargetHit tracking */
+USTRUCT()
+struct FLyraGameplayAbilityTargetData_SingleTargetHit : public FGameplayAbilityTargetData_SingleTargetHit
+{
+	GENERATED_BODY()
+
+	FLyraGameplayAbilityTargetData_SingleTargetHit()
+		: CartridgeID(-1)
+	{ }
+
+	virtual void AddTargetDataToContext(FGameplayEffectContextHandle& Context, bool bIncludeActorArray) const override;
+
+	/** ID to allow the identification of multiple bullets that were part of the same cartridge */
+	UPROPERTY()
+	int32 CartridgeID;
+
+	bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
+
+	virtual UScriptStruct* GetScriptStruct() const override
+	{
+		return FLyraGameplayAbilityTargetData_SingleTargetHit::StaticStruct();
+	}
+};
+
+template<>
+struct TStructOpsTypeTraits<FLyraGameplayAbilityTargetData_SingleTargetHit> : public TStructOpsTypeTraitsBase2<FLyraGameplayAbilityTargetData_SingleTargetHit>
+{
+	enum
+	{
+		WithNetSerializer = true	// For now this is REQUIRED for FGameplayAbilityTargetDataHandle net serialization to work
+	};
+};
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraGameplayCueManager.cpp

@@ -0,0 +1,406 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraGameplayCueManager.h"
+#include "Engine/AssetManager.h"
+#include "LyraLogChannels.h"
+#include "GameplayCueSet.h"
+#include "AbilitySystemGlobals.h"
+#include "GameplayTagsManager.h"
+#include "UObject/UObjectThreadContext.h"
+#include "Async/Async.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraGameplayCueManager)
+
+//////////////////////////////////////////////////////////////////////
+
+enum class ELyraEditorLoadMode
+{
+	// Loads all cues upfront; longer loading speed in the editor but short PIE times and effects never fail to play
+	LoadUpfront,
+
+	// Outside of editor: Async loads as cue tag are registered
+	// In editor: Async loads when cues are invoked
+	//   Note: This can cause some 'why didn't I see the effect for X' issues in PIE and is good for iteration speed but otherwise bad for designers
+	PreloadAsCuesAreReferenced_GameOnly,
+
+	// Async loads as cue tag are registered
+	PreloadAsCuesAreReferenced
+};
+
+namespace LyraGameplayCueManagerCvars
+{
+	static FAutoConsoleCommand CVarDumpGameplayCues(
+		TEXT("Lyra.DumpGameplayCues"),
+		TEXT("Shows all assets that were loaded via LyraGameplayCueManager and are currently in memory."),
+		FConsoleCommandWithArgsDelegate::CreateStatic(ULyraGameplayCueManager::DumpGameplayCues));
+
+	static ELyraEditorLoadMode LoadMode = ELyraEditorLoadMode::LoadUpfront;
+}
+
+const bool bPreloadEvenInEditor = true;
+
+//////////////////////////////////////////////////////////////////////
+
+struct FGameplayCueTagThreadSynchronizeGraphTask : public FAsyncGraphTaskBase
+{
+	TFunction<void()> TheTask;
+	FGameplayCueTagThreadSynchronizeGraphTask(TFunction<void()>&& Task) : TheTask(MoveTemp(Task)) { }
+	void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) { TheTask(); }
+	ENamedThreads::Type GetDesiredThread() { return ENamedThreads::GameThread; }
+};
+
+//////////////////////////////////////////////////////////////////////
+
+ULyraGameplayCueManager::ULyraGameplayCueManager(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+ULyraGameplayCueManager* ULyraGameplayCueManager::Get()
+{
+	return Cast<ULyraGameplayCueManager>(UAbilitySystemGlobals::Get().GetGameplayCueManager());
+}
+
+void ULyraGameplayCueManager::OnCreated()
+{
+	Super::OnCreated();
+
+	UpdateDelayLoadDelegateListeners();
+}
+
+void ULyraGameplayCueManager::LoadAlwaysLoadedCues()
+{
+	if (ShouldDelayLoadGameplayCues())
+	{
+		UGameplayTagsManager& TagManager = UGameplayTagsManager::Get();
+	
+		//@TODO: Try to collect these by filtering GameplayCue. tags out of native gameplay tags?
+		TArray<FName> AdditionalAlwaysLoadedCueTags;
+
+		for (const FName& CueTagName : AdditionalAlwaysLoadedCueTags)
+		{
+			FGameplayTag CueTag = TagManager.RequestGameplayTag(CueTagName, /*ErrorIfNotFound=*/ false);
+			if (CueTag.IsValid())
+			{
+				ProcessTagToPreload(CueTag, nullptr);
+			}
+			else
+			{
+				UE_LOG(LogLyra, Warning, TEXT("ULyraGameplayCueManager::AdditionalAlwaysLoadedCueTags contains invalid tag %s"), *CueTagName.ToString());
+			}
+		}
+	}
+}
+
+bool ULyraGameplayCueManager::ShouldAsyncLoadRuntimeObjectLibraries() const
+{
+	switch (LyraGameplayCueManagerCvars::LoadMode)
+	{
+	case ELyraEditorLoadMode::LoadUpfront:
+		return true;
+	case ELyraEditorLoadMode::PreloadAsCuesAreReferenced_GameOnly:
+#if WITH_EDITOR
+		if (GIsEditor)
+		{
+			return false;
+		}
+#endif
+		break;
+	case ELyraEditorLoadMode::PreloadAsCuesAreReferenced:
+		break;
+	}
+
+	return !ShouldDelayLoadGameplayCues();
+}
+
+bool ULyraGameplayCueManager::ShouldSyncLoadMissingGameplayCues() const
+{
+	return false;
+}
+
+bool ULyraGameplayCueManager::ShouldAsyncLoadMissingGameplayCues() const
+{
+	return true;
+}
+
+void ULyraGameplayCueManager::DumpGameplayCues(const TArray<FString>& Args)
+{
+	ULyraGameplayCueManager* GCM = Cast<ULyraGameplayCueManager>(UAbilitySystemGlobals::Get().GetGameplayCueManager());
+	if (!GCM)
+	{
+		UE_LOG(LogLyra, Error, TEXT("DumpGameplayCues failed. No ULyraGameplayCueManager found."));
+		return;
+	}
+
+	const bool bIncludeRefs = Args.Contains(TEXT("Refs"));
+
+	UE_LOG(LogLyra, Log, TEXT("=========== Dumping Always Loaded Gameplay Cue Notifies ==========="));
+	for (UClass* CueClass : GCM->AlwaysLoadedCues)
+	{
+		UE_LOG(LogLyra, Log, TEXT("  %s"), *GetPathNameSafe(CueClass));
+	}
+
+	UE_LOG(LogLyra, Log, TEXT("=========== Dumping Preloaded Gameplay Cue Notifies ==========="));
+	for (UClass* CueClass : GCM->PreloadedCues)
+	{
+		TSet<FObjectKey>* ReferencerSet = GCM->PreloadedCueReferencers.Find(CueClass);
+		int32 NumRefs = ReferencerSet ? ReferencerSet->Num() : 0;
+		UE_LOG(LogLyra, Log, TEXT("  %s (%d refs)"), *GetPathNameSafe(CueClass), NumRefs);
+		if (bIncludeRefs && ReferencerSet)
+		{
+			for (const FObjectKey& Ref : *ReferencerSet)
+			{
+				UObject* RefObject = Ref.ResolveObjectPtr();
+				UE_LOG(LogLyra, Log, TEXT("    ^- %s"), *GetPathNameSafe(RefObject));
+			}
+		}
+	}
+
+	UE_LOG(LogLyra, Log, TEXT("=========== Dumping Gameplay Cue Notifies loaded on demand ==========="));
+	int32 NumMissingCuesLoaded = 0;
+	if (GCM->RuntimeGameplayCueObjectLibrary.CueSet)
+	{
+		for (const FGameplayCueNotifyData& CueData : GCM->RuntimeGameplayCueObjectLibrary.CueSet->GameplayCueData)
+		{
+			if (CueData.LoadedGameplayCueClass && !GCM->AlwaysLoadedCues.Contains(CueData.LoadedGameplayCueClass) && !GCM->PreloadedCues.Contains(CueData.LoadedGameplayCueClass))
+			{
+				NumMissingCuesLoaded++;
+				UE_LOG(LogLyra, Log, TEXT("  %s"), *CueData.LoadedGameplayCueClass->GetPathName());
+			}
+		}
+	}
+
+	UE_LOG(LogLyra, Log, TEXT("=========== Gameplay Cue Notify summary ==========="));
+	UE_LOG(LogLyra, Log, TEXT("  ... %d cues in always loaded list"), GCM->AlwaysLoadedCues.Num());
+	UE_LOG(LogLyra, Log, TEXT("  ... %d cues in preloaded list"), GCM->PreloadedCues.Num());
+	UE_LOG(LogLyra, Log, TEXT("  ... %d cues loaded on demand"), NumMissingCuesLoaded);
+	UE_LOG(LogLyra, Log, TEXT("  ... %d cues in total"), GCM->AlwaysLoadedCues.Num() + GCM->PreloadedCues.Num() + NumMissingCuesLoaded);
+}
+
+void ULyraGameplayCueManager::OnGameplayTagLoaded(const FGameplayTag& Tag)
+{
+	FScopeLock ScopeLock(&LoadedGameplayTagsToProcessCS);
+	bool bStartTask = LoadedGameplayTagsToProcess.Num() == 0;
+	FUObjectSerializeContext* LoadContext = FUObjectThreadContext::Get().GetSerializeContext();
+	UObject* OwningObject = LoadContext ? LoadContext->SerializedObject : nullptr;
+	LoadedGameplayTagsToProcess.Emplace(Tag, OwningObject);
+	if (bStartTask)
+	{
+		TGraphTask<FGameplayCueTagThreadSynchronizeGraphTask>::CreateTask().ConstructAndDispatchWhenReady([]()
+			{
+				if (GIsRunning)
+				{
+					if (ULyraGameplayCueManager* StrongThis = Get())
+					{
+						// If we are garbage collecting we cannot call StaticFindObject (or a few other static uobject functions), so we'll just wait until the GC is over and process the tags then
+						if (IsGarbageCollecting())
+						{
+							StrongThis->bProcessLoadedTagsAfterGC = true;
+						}
+						else
+						{
+							StrongThis->ProcessLoadedTags();
+						}
+					}
+				}
+			});
+	}
+}
+
+void ULyraGameplayCueManager::HandlePostGarbageCollect()
+{
+	if (bProcessLoadedTagsAfterGC)
+	{
+		ProcessLoadedTags();
+	}
+	bProcessLoadedTagsAfterGC = false;
+}
+
+void ULyraGameplayCueManager::ProcessLoadedTags()
+{
+	TArray<FLoadedGameplayTagToProcessData> TaskLoadedGameplayTagsToProcess;
+	{
+		// Lock LoadedGameplayTagsToProcess just long enough to make a copy and clear
+		FScopeLock TaskScopeLock(&LoadedGameplayTagsToProcessCS);
+		TaskLoadedGameplayTagsToProcess = LoadedGameplayTagsToProcess;
+		LoadedGameplayTagsToProcess.Empty();
+	}
+
+	// This might return during shutdown, and we don't want to proceed if that is the case
+	if (GIsRunning)
+	{
+		if (RuntimeGameplayCueObjectLibrary.CueSet)
+		{
+			for (const FLoadedGameplayTagToProcessData& LoadedTagData : TaskLoadedGameplayTagsToProcess)
+			{
+				if (RuntimeGameplayCueObjectLibrary.CueSet->GameplayCueDataMap.Contains(LoadedTagData.Tag))
+				{
+					if (!LoadedTagData.WeakOwner.IsStale())
+					{
+						ProcessTagToPreload(LoadedTagData.Tag, LoadedTagData.WeakOwner.Get());
+					}
+				}
+			}
+		}
+		else
+		{
+			UE_LOG(LogLyra, Warning, TEXT("ULyraGameplayCueManager::OnGameplayTagLoaded processed loaded tag(s) but RuntimeGameplayCueObjectLibrary.CueSet was null. Skipping processing."));
+		}
+	}
+}
+
+void ULyraGameplayCueManager::ProcessTagToPreload(const FGameplayTag& Tag, UObject* OwningObject)
+{
+	switch (LyraGameplayCueManagerCvars::LoadMode)
+	{
+	case ELyraEditorLoadMode::LoadUpfront:
+		return;
+	case ELyraEditorLoadMode::PreloadAsCuesAreReferenced_GameOnly:
+#if WITH_EDITOR
+		if (GIsEditor)
+		{
+			return;
+		}
+#endif
+		break;
+	case ELyraEditorLoadMode::PreloadAsCuesAreReferenced:
+		break;
+	}
+
+	check(RuntimeGameplayCueObjectLibrary.CueSet);
+
+	int32* DataIdx = RuntimeGameplayCueObjectLibrary.CueSet->GameplayCueDataMap.Find(Tag);
+	if (DataIdx && RuntimeGameplayCueObjectLibrary.CueSet->GameplayCueData.IsValidIndex(*DataIdx))
+	{
+		const FGameplayCueNotifyData& CueData = RuntimeGameplayCueObjectLibrary.CueSet->GameplayCueData[*DataIdx];
+
+		UClass* LoadedGameplayCueClass = FindObject<UClass>(nullptr, *CueData.GameplayCueNotifyObj.ToString());
+		if (LoadedGameplayCueClass)
+		{
+			RegisterPreloadedCue(LoadedGameplayCueClass, OwningObject);
+		}
+		else
+		{
+			bool bAlwaysLoadedCue = OwningObject == nullptr;
+			TWeakObjectPtr<UObject> WeakOwner = OwningObject;
+			StreamableManager.RequestAsyncLoad(CueData.GameplayCueNotifyObj, FStreamableDelegate::CreateUObject(this, &ThisClass::OnPreloadCueComplete, CueData.GameplayCueNotifyObj, WeakOwner, bAlwaysLoadedCue), FStreamableManager::DefaultAsyncLoadPriority, false, false, TEXT("GameplayCueManager"));
+		}
+	}
+}
+
+void ULyraGameplayCueManager::OnPreloadCueComplete(FSoftObjectPath Path, TWeakObjectPtr<UObject> OwningObject, bool bAlwaysLoadedCue)
+{
+	if (bAlwaysLoadedCue || OwningObject.IsValid())
+	{
+		if (UClass* LoadedGameplayCueClass = Cast<UClass>(Path.ResolveObject()))
+		{
+			RegisterPreloadedCue(LoadedGameplayCueClass, OwningObject.Get());
+		}
+	}
+}
+
+void ULyraGameplayCueManager::RegisterPreloadedCue(UClass* LoadedGameplayCueClass, UObject* OwningObject)
+{
+	check(LoadedGameplayCueClass);
+
+	const bool bAlwaysLoadedCue = OwningObject == nullptr;
+	if (bAlwaysLoadedCue)
+	{
+		AlwaysLoadedCues.Add(LoadedGameplayCueClass);
+		PreloadedCues.Remove(LoadedGameplayCueClass);
+		PreloadedCueReferencers.Remove(LoadedGameplayCueClass);
+	}
+	else if ((OwningObject != LoadedGameplayCueClass) && (OwningObject != LoadedGameplayCueClass->GetDefaultObject()) && !AlwaysLoadedCues.Contains(LoadedGameplayCueClass))
+	{
+		PreloadedCues.Add(LoadedGameplayCueClass);
+		TSet<FObjectKey>& ReferencerSet = PreloadedCueReferencers.FindOrAdd(LoadedGameplayCueClass);
+		ReferencerSet.Add(OwningObject);
+	}
+}
+
+void ULyraGameplayCueManager::HandlePostLoadMap(UWorld* NewWorld)
+{
+	if (RuntimeGameplayCueObjectLibrary.CueSet)
+	{
+		for (UClass* CueClass : AlwaysLoadedCues)
+		{
+			RuntimeGameplayCueObjectLibrary.CueSet->RemoveLoadedClass(CueClass);
+		}
+
+		for (UClass* CueClass : PreloadedCues)
+		{
+			RuntimeGameplayCueObjectLibrary.CueSet->RemoveLoadedClass(CueClass);
+		}
+	}
+
+	for (auto CueIt = PreloadedCues.CreateIterator(); CueIt; ++CueIt)
+	{
+		TSet<FObjectKey>& ReferencerSet = PreloadedCueReferencers.FindChecked(*CueIt);
+		for (auto RefIt = ReferencerSet.CreateIterator(); RefIt; ++RefIt)
+		{
+			if (!RefIt->ResolveObjectPtr())
+			{
+				RefIt.RemoveCurrent();
+			}
+		}
+		if (ReferencerSet.Num() == 0)
+		{
+			PreloadedCueReferencers.Remove(*CueIt);
+			CueIt.RemoveCurrent();
+		}
+	}
+}
+
+void ULyraGameplayCueManager::UpdateDelayLoadDelegateListeners()
+{
+	UGameplayTagsManager::Get().OnGameplayTagLoadedDelegate.RemoveAll(this);
+	FCoreUObjectDelegates::GetPostGarbageCollect().RemoveAll(this);
+	FCoreUObjectDelegates::PostLoadMapWithWorld.RemoveAll(this);
+
+	switch (LyraGameplayCueManagerCvars::LoadMode)
+	{
+	case ELyraEditorLoadMode::LoadUpfront:
+		return;
+	case ELyraEditorLoadMode::PreloadAsCuesAreReferenced_GameOnly:
+#if WITH_EDITOR
+		if (GIsEditor)
+		{
+			return;
+		}
+#endif
+		break;
+	case ELyraEditorLoadMode::PreloadAsCuesAreReferenced:
+		break;
+	}
+
+	UGameplayTagsManager::Get().OnGameplayTagLoadedDelegate.AddUObject(this, &ThisClass::OnGameplayTagLoaded);
+	FCoreUObjectDelegates::GetPostGarbageCollect().AddUObject(this, &ThisClass::HandlePostGarbageCollect);
+	FCoreUObjectDelegates::PostLoadMapWithWorld.AddUObject(this, &ThisClass::HandlePostLoadMap);
+}
+
+bool ULyraGameplayCueManager::ShouldDelayLoadGameplayCues() const
+{
+	const bool bClientDelayLoadGameplayCues = true;
+	return !IsRunningDedicatedServer() && bClientDelayLoadGameplayCues;
+}
+
+const FPrimaryAssetType UFortAssetManager_GameplayCueRefsType = TEXT("GameplayCueRefs");
+const FName UFortAssetManager_GameplayCueRefsName = TEXT("GameplayCueReferences");
+const FName UFortAssetManager_LoadStateClient = FName(TEXT("Client"));
+
+void ULyraGameplayCueManager::RefreshGameplayCuePrimaryAsset()
+{
+	TArray<FSoftObjectPath> CuePaths;
+	UGameplayCueSet* RuntimeGameplayCueSet = GetRuntimeCueSet();
+	if (RuntimeGameplayCueSet)
+	{
+		RuntimeGameplayCueSet->GetSoftObjectPaths(CuePaths);
+	}
+
+	FAssetBundleData BundleData;
+	BundleData.AddBundleAssetsTruncated(UFortAssetManager_LoadStateClient, CuePaths);
+
+	FPrimaryAssetId PrimaryAssetId = FPrimaryAssetId(UFortAssetManager_GameplayCueRefsType, UFortAssetManager_GameplayCueRefsName);
+	UAssetManager::Get().AddDynamicAsset(PrimaryAssetId, FSoftObjectPath(), BundleData);
+}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraGameplayCueManager.h

@@ -0,0 +1,79 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "GameplayCueManager.h"
+
+#include "LyraGameplayCueManager.generated.h"
+
+class FString;
+class UClass;
+class UObject;
+class UWorld;
+struct FObjectKey;
+
+/**
+ * ULyraGameplayCueManager
+ *
+ * Game-specific manager for gameplay cues
+ */
+UCLASS()
+class ULyraGameplayCueManager : public UGameplayCueManager
+{
+	GENERATED_BODY()
+
+public:
+	ULyraGameplayCueManager(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
+
+	static ULyraGameplayCueManager* Get();
+
+	//~UGameplayCueManager interface
+	virtual void OnCreated() override;
+	virtual bool ShouldAsyncLoadRuntimeObjectLibraries() const override;
+	virtual bool ShouldSyncLoadMissingGameplayCues() const override;
+	virtual bool ShouldAsyncLoadMissingGameplayCues() const override;
+	//~End of UGameplayCueManager interface
+
+	static void DumpGameplayCues(const TArray<FString>& Args);
+
+	// When delay loading cues, this will load the cues that must be always loaded anyway
+	void LoadAlwaysLoadedCues();
+
+	// Updates the bundles for the singular gameplay cue primary asset
+	void RefreshGameplayCuePrimaryAsset();
+
+private:
+	void OnGameplayTagLoaded(const FGameplayTag& Tag);
+	void HandlePostGarbageCollect();
+	void ProcessLoadedTags();
+	void ProcessTagToPreload(const FGameplayTag& Tag, UObject* OwningObject);
+	void OnPreloadCueComplete(FSoftObjectPath Path, TWeakObjectPtr<UObject> OwningObject, bool bAlwaysLoadedCue);
+	void RegisterPreloadedCue(UClass* LoadedGameplayCueClass, UObject* OwningObject);
+	void HandlePostLoadMap(UWorld* NewWorld);
+	void UpdateDelayLoadDelegateListeners();
+	bool ShouldDelayLoadGameplayCues() const;
+
+private:
+	struct FLoadedGameplayTagToProcessData
+	{
+		FGameplayTag Tag;
+		TWeakObjectPtr<UObject> WeakOwner;
+
+		FLoadedGameplayTagToProcessData() {}
+		FLoadedGameplayTagToProcessData(const FGameplayTag& InTag, const TWeakObjectPtr<UObject>& InWeakOwner) : Tag(InTag), WeakOwner(InWeakOwner) {}
+	};
+
+private:
+	// Cues that were preloaded on the client due to being referenced by content
+	UPROPERTY(transient)
+	TSet<TObjectPtr<UClass>> PreloadedCues;
+	TMap<FObjectKey, TSet<FObjectKey>> PreloadedCueReferencers;
+
+	// Cues that were preloaded on the client and will always be loaded (code referenced or explicitly always loaded)
+	UPROPERTY(transient)
+	TSet<TObjectPtr<UClass>> AlwaysLoadedCues;
+
+	TArray<FLoadedGameplayTagToProcessData> LoadedGameplayTagsToProcess;
+	FCriticalSection LoadedGameplayTagsToProcessCS;
+	bool bProcessLoadedTagsAfterGC = false;
+};

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraGameplayEffectContext.cpp

@@ -0,0 +1,67 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraGameplayEffectContext.h"
+
+#include "AbilitySystem/LyraAbilitySourceInterface.h"
+#include "Engine/HitResult.h"
+#include "PhysicalMaterials/PhysicalMaterial.h"
+
+#if UE_WITH_IRIS
+#include "Iris/ReplicationState/PropertyNetSerializerInfoRegistry.h"
+#include "Serialization/GameplayEffectContextNetSerializer.h"
+#endif
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraGameplayEffectContext)
+
+class FArchive;
+
+FLyraGameplayEffectContext* FLyraGameplayEffectContext::ExtractEffectContext(struct FGameplayEffectContextHandle Handle)
+{
+	FGameplayEffectContext* BaseEffectContext = Handle.Get();
+	if ((BaseEffectContext != nullptr) && BaseEffectContext->GetScriptStruct()->IsChildOf(FLyraGameplayEffectContext::StaticStruct()))
+	{
+		return (FLyraGameplayEffectContext*)BaseEffectContext;
+	}
+
+	return nullptr;
+}
+
+bool FLyraGameplayEffectContext::NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess)
+{
+	FGameplayEffectContext::NetSerialize(Ar, Map, bOutSuccess);
+
+	// Not serialized for post-activation use:
+	// CartridgeID
+
+	return true;
+}
+
+#if UE_WITH_IRIS
+namespace UE::Net
+{
+	// Forward to FGameplayEffectContextNetSerializer
+	// Note: If FLyraGameplayEffectContext::NetSerialize() is modified, a custom NetSerializesr must be implemented as the current fallback will no longer be sufficient.
+	UE_NET_IMPLEMENT_FORWARDING_NETSERIALIZER_AND_REGISTRY_DELEGATES(LyraGameplayEffectContext, FGameplayEffectContextNetSerializer);
+}
+#endif
+
+void FLyraGameplayEffectContext::SetAbilitySource(const ILyraAbilitySourceInterface* InObject, float InSourceLevel)
+{
+	AbilitySourceObject = MakeWeakObjectPtr(Cast<const UObject>(InObject));
+	//SourceLevel = InSourceLevel;
+}
+
+const ILyraAbilitySourceInterface* FLyraGameplayEffectContext::GetAbilitySource() const
+{
+	return Cast<ILyraAbilitySourceInterface>(AbilitySourceObject.Get());
+}
+
+const UPhysicalMaterial* FLyraGameplayEffectContext::GetPhysicalMaterial() const
+{
+	if (const FHitResult* HitResultPtr = GetHitResult())
+	{
+		return HitResultPtr->PhysMaterial.Get();
+	}
+	return nullptr;
+}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraGameplayEffectContext.h

@@ -0,0 +1,82 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "GameplayEffectTypes.h"
+
+#include "LyraGameplayEffectContext.generated.h"
+
+class AActor;
+class FArchive;
+class ILyraAbilitySourceInterface;
+class UObject;
+class UPhysicalMaterial;
+
+USTRUCT()
+struct FLyraGameplayEffectContext : public FGameplayEffectContext
+{
+	GENERATED_BODY()
+
+	FLyraGameplayEffectContext()
+		: FGameplayEffectContext()
+	{
+	}
+
+	FLyraGameplayEffectContext(AActor* InInstigator, AActor* InEffectCauser)
+		: FGameplayEffectContext(InInstigator, InEffectCauser)
+	{
+	}
+
+	/** Returns the wrapped FLyraGameplayEffectContext from the handle, or nullptr if it doesn't exist or is the wrong type */
+	static LYRAGAME_API FLyraGameplayEffectContext* ExtractEffectContext(struct FGameplayEffectContextHandle Handle);
+
+	/** Sets the object used as the ability source */
+	void SetAbilitySource(const ILyraAbilitySourceInterface* InObject, float InSourceLevel);
+
+	/** Returns the ability source interface associated with the source object. Only valid on the authority. */
+	const ILyraAbilitySourceInterface* GetAbilitySource() const;
+
+	virtual FGameplayEffectContext* Duplicate() const override
+	{
+		FLyraGameplayEffectContext* NewContext = new FLyraGameplayEffectContext();
+		*NewContext = *this;
+		if (GetHitResult())
+		{
+			// Does a deep copy of the hit result
+			NewContext->AddHitResult(*GetHitResult(), true);
+		}
+		return NewContext;
+	}
+
+	virtual UScriptStruct* GetScriptStruct() const override
+	{
+		return FLyraGameplayEffectContext::StaticStruct();
+	}
+
+	/** Overridden to serialize new fields */
+	virtual bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess) override;
+
+	/** Returns the physical material from the hit result if there is one */
+	const UPhysicalMaterial* GetPhysicalMaterial() const;
+
+public:
+	/** ID to allow the identification of multiple bullets that were part of the same cartridge */
+	UPROPERTY()
+	int32 CartridgeID = -1;
+
+protected:
+	/** Ability Source object (should implement ILyraAbilitySourceInterface). NOT replicated currently */
+	UPROPERTY()
+	TWeakObjectPtr<const UObject> AbilitySourceObject;
+};
+
+template<>
+struct TStructOpsTypeTraits<FLyraGameplayEffectContext> : public TStructOpsTypeTraitsBase2<FLyraGameplayEffectContext>
+{
+	enum
+	{
+		WithNetSerializer = true,
+		WithCopy = true
+	};
+};
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraGlobalAbilitySystem.cpp

@@ -0,0 +1,156 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraGlobalAbilitySystem.h"
+
+#include "AbilitySystem/LyraAbilitySystemComponent.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraGlobalAbilitySystem)
+
+void FGlobalAppliedAbilityList::AddToASC(TSubclassOf<UGameplayAbility> Ability, ULyraAbilitySystemComponent* ASC)
+{
+	if (FGameplayAbilitySpecHandle* SpecHandle = Handles.Find(ASC))
+	{
+		RemoveFromASC(ASC);
+	}
+
+	UGameplayAbility* AbilityCDO = Ability->GetDefaultObject<UGameplayAbility>();
+	FGameplayAbilitySpec AbilitySpec(AbilityCDO);
+	const FGameplayAbilitySpecHandle AbilitySpecHandle = ASC->GiveAbility(AbilitySpec);
+	Handles.Add(ASC, AbilitySpecHandle);
+}
+
+void FGlobalAppliedAbilityList::RemoveFromASC(ULyraAbilitySystemComponent* ASC)
+{
+	if (FGameplayAbilitySpecHandle* SpecHandle = Handles.Find(ASC))
+	{
+		ASC->ClearAbility(*SpecHandle);
+		Handles.Remove(ASC);
+	}
+}
+
+void FGlobalAppliedAbilityList::RemoveFromAll()
+{
+	for (auto& KVP : Handles)
+	{
+		if (KVP.Key != nullptr)
+		{
+			KVP.Key->ClearAbility(KVP.Value);
+		}
+	}
+	Handles.Empty();
+}
+
+
+
+void FGlobalAppliedEffectList::AddToASC(TSubclassOf<UGameplayEffect> Effect, ULyraAbilitySystemComponent* ASC)
+{
+	if (FActiveGameplayEffectHandle* EffectHandle = Handles.Find(ASC))
+	{
+		RemoveFromASC(ASC);
+	}
+
+	const UGameplayEffect* GameplayEffectCDO = Effect->GetDefaultObject<UGameplayEffect>();
+	const FActiveGameplayEffectHandle GameplayEffectHandle = ASC->ApplyGameplayEffectToSelf(GameplayEffectCDO, /*Level=*/ 1, ASC->MakeEffectContext());
+	Handles.Add(ASC, GameplayEffectHandle);
+}
+
+void FGlobalAppliedEffectList::RemoveFromASC(ULyraAbilitySystemComponent* ASC)
+{
+	if (FActiveGameplayEffectHandle* EffectHandle = Handles.Find(ASC))
+	{
+		ASC->RemoveActiveGameplayEffect(*EffectHandle);
+		Handles.Remove(ASC);
+	}
+}
+
+void FGlobalAppliedEffectList::RemoveFromAll()
+{
+	for (auto& KVP : Handles)
+	{
+		if (KVP.Key != nullptr)
+		{
+			KVP.Key->RemoveActiveGameplayEffect(KVP.Value);
+		}
+	}
+	Handles.Empty();
+}
+
+ULyraGlobalAbilitySystem::ULyraGlobalAbilitySystem()
+{
+}
+
+void ULyraGlobalAbilitySystem::ApplyAbilityToAll(TSubclassOf<UGameplayAbility> Ability)
+{
+	if ((Ability.Get() != nullptr) && (!AppliedAbilities.Contains(Ability)))
+	{
+		FGlobalAppliedAbilityList& Entry = AppliedAbilities.Add(Ability);		
+		for (ULyraAbilitySystemComponent* ASC : RegisteredASCs)
+		{
+			Entry.AddToASC(Ability, ASC);
+		}
+	}
+}
+
+void ULyraGlobalAbilitySystem::ApplyEffectToAll(TSubclassOf<UGameplayEffect> Effect)
+{
+	if ((Effect.Get() != nullptr) && (!AppliedEffects.Contains(Effect)))
+	{
+		FGlobalAppliedEffectList& Entry = AppliedEffects.Add(Effect);
+		for (ULyraAbilitySystemComponent* ASC : RegisteredASCs)
+		{
+			Entry.AddToASC(Effect, ASC);
+		}
+	}
+}
+
+void ULyraGlobalAbilitySystem::RemoveAbilityFromAll(TSubclassOf<UGameplayAbility> Ability)
+{
+	if ((Ability.Get() != nullptr) && AppliedAbilities.Contains(Ability))
+	{
+		FGlobalAppliedAbilityList& Entry = AppliedAbilities[Ability];
+		Entry.RemoveFromAll();
+		AppliedAbilities.Remove(Ability);
+	}
+}
+
+void ULyraGlobalAbilitySystem::RemoveEffectFromAll(TSubclassOf<UGameplayEffect> Effect)
+{
+	if ((Effect.Get() != nullptr) && AppliedEffects.Contains(Effect))
+	{
+		FGlobalAppliedEffectList& Entry = AppliedEffects[Effect];
+		Entry.RemoveFromAll();
+		AppliedEffects.Remove(Effect);
+	}
+}
+
+void ULyraGlobalAbilitySystem::RegisterASC(ULyraAbilitySystemComponent* ASC)
+{
+	check(ASC);
+
+	for (auto& Entry : AppliedAbilities)
+	{
+		Entry.Value.AddToASC(Entry.Key, ASC);
+	}
+	for (auto& Entry : AppliedEffects)
+	{
+		Entry.Value.AddToASC(Entry.Key, ASC);
+	}
+
+	RegisteredASCs.AddUnique(ASC);
+}
+
+void ULyraGlobalAbilitySystem::UnregisterASC(ULyraAbilitySystemComponent* ASC)
+{
+	check(ASC);
+	for (auto& Entry : AppliedAbilities)
+	{
+		Entry.Value.RemoveFromASC(ASC);
+	}
+	for (auto& Entry : AppliedEffects)
+	{
+		Entry.Value.RemoveFromASC(ASC);
+	}
+
+	RegisteredASCs.Remove(ASC);
+}
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraGlobalAbilitySystem.h

@@ -0,0 +1,81 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "ActiveGameplayEffectHandle.h"
+#include "Subsystems/WorldSubsystem.h"
+#include "GameplayAbilitySpecHandle.h"
+#include "Templates/SubclassOf.h"
+
+#include "LyraGlobalAbilitySystem.generated.h"
+
+class UGameplayAbility;
+class UGameplayEffect;
+class ULyraAbilitySystemComponent;
+class UObject;
+struct FActiveGameplayEffectHandle;
+struct FFrame;
+struct FGameplayAbilitySpecHandle;
+
+USTRUCT()
+struct FGlobalAppliedAbilityList
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	TMap<TObjectPtr<ULyraAbilitySystemComponent>, FGameplayAbilitySpecHandle> Handles;
+
+	void AddToASC(TSubclassOf<UGameplayAbility> Ability, ULyraAbilitySystemComponent* ASC);
+	void RemoveFromASC(ULyraAbilitySystemComponent* ASC);
+	void RemoveFromAll();
+};
+
+USTRUCT()
+struct FGlobalAppliedEffectList
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	TMap<TObjectPtr<ULyraAbilitySystemComponent>, FActiveGameplayEffectHandle> Handles;
+
+	void AddToASC(TSubclassOf<UGameplayEffect> Effect, ULyraAbilitySystemComponent* ASC);
+	void RemoveFromASC(ULyraAbilitySystemComponent* ASC);
+	void RemoveFromAll();
+};
+
+UCLASS()
+class ULyraGlobalAbilitySystem : public UWorldSubsystem
+{
+	GENERATED_BODY()
+
+public:
+	ULyraGlobalAbilitySystem();
+
+	UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category="Lyra")
+	void ApplyAbilityToAll(TSubclassOf<UGameplayAbility> Ability);
+
+	UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category="Lyra")
+	void ApplyEffectToAll(TSubclassOf<UGameplayEffect> Effect);
+
+	UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = "Lyra")
+	void RemoveAbilityFromAll(TSubclassOf<UGameplayAbility> Ability);
+
+	UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = "Lyra")
+	void RemoveEffectFromAll(TSubclassOf<UGameplayEffect> Effect);
+
+	/** Register an ASC with global system and apply any active global effects/abilities. */
+	void RegisterASC(ULyraAbilitySystemComponent* ASC);
+
+	/** Removes an ASC from the global system, along with any active global effects/abilities. */
+	void UnregisterASC(ULyraAbilitySystemComponent* ASC);
+
+private:
+	UPROPERTY()
+	TMap<TSubclassOf<UGameplayAbility>, FGlobalAppliedAbilityList> AppliedAbilities;
+
+	UPROPERTY()
+	TMap<TSubclassOf<UGameplayEffect>, FGlobalAppliedEffectList> AppliedEffects;
+
+	UPROPERTY()
+	TArray<TObjectPtr<ULyraAbilitySystemComponent>> RegisteredASCs;
+};

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraTaggedActor.cpp

@@ -0,0 +1,30 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraTaggedActor.h"
+#include "UObject/UnrealType.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraTaggedActor)
+
+ALyraTaggedActor::ALyraTaggedActor(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+void ALyraTaggedActor::GetOwnedGameplayTags(FGameplayTagContainer& TagContainer) const
+{
+	TagContainer.AppendTags(StaticGameplayTags);
+}
+
+#if WITH_EDITOR
+bool ALyraTaggedActor::CanEditChange(const FProperty* InProperty) const
+{
+	// Prevent editing of the other tags property
+	if (InProperty->GetFName() == GET_MEMBER_NAME_CHECKED(AActor, Tags))
+	{
+		return false;
+	}
+
+	return Super::CanEditChange(InProperty);
+}
+#endif
+

LyraStarterGame/Source/LyraGame/AbilitySystem/LyraTaggedActor.h

@@ -0,0 +1,36 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "GameFramework/Actor.h"
+#include "GameplayTagAssetInterface.h"
+#include "GameplayTagContainer.h"
+
+#include "LyraTaggedActor.generated.h"
+
+// An actor that implements the gameplay tag asset interface
+UCLASS()
+class ALyraTaggedActor : public AActor, public IGameplayTagAssetInterface
+{
+	GENERATED_BODY()
+
+public:
+
+	ALyraTaggedActor(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
+
+	//~IGameplayTagAssetInterface
+	virtual void GetOwnedGameplayTags(FGameplayTagContainer& TagContainer) const override;
+	//~End of IGameplayTagAssetInterface
+
+	//~UObject interface
+#if WITH_EDITOR
+	virtual bool CanEditChange(const FProperty* InProperty) const override;
+#endif
+	//~End of UObject interface
+
+protected:
+	// Gameplay-related tags associated with this actor
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Actor)
+	FGameplayTagContainer StaticGameplayTags;
+};
+

LyraStarterGame/Source/LyraGame/Animation/LyraAnimInstance.cpp

@@ -0,0 +1,65 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraAnimInstance.h"
+#include "AbilitySystemGlobals.h"
+#include "Character/LyraCharacter.h"
+#include "Character/LyraCharacterMovementComponent.h"
+
+#if WITH_EDITOR
+#include "Misc/DataValidation.h"
+#endif
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraAnimInstance)
+
+
+ULyraAnimInstance::ULyraAnimInstance(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+void ULyraAnimInstance::InitializeWithAbilitySystem(UAbilitySystemComponent* ASC)
+{
+	check(ASC);
+
+	GameplayTagPropertyMap.Initialize(this, ASC);
+}
+
+#if WITH_EDITOR
+EDataValidationResult ULyraAnimInstance::IsDataValid(FDataValidationContext& Context) const
+{
+	Super::IsDataValid(Context);
+
+	GameplayTagPropertyMap.IsDataValid(this, Context);
+
+	return ((Context.GetNumErrors() > 0) ? EDataValidationResult::Invalid : EDataValidationResult::Valid);
+}
+#endif // WITH_EDITOR
+
+void ULyraAnimInstance::NativeInitializeAnimation()
+{
+	Super::NativeInitializeAnimation();
+
+	if (AActor* OwningActor = GetOwningActor())
+	{
+		if (UAbilitySystemComponent* ASC = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(OwningActor))
+		{
+			InitializeWithAbilitySystem(ASC);
+		}
+	}
+}
+
+void ULyraAnimInstance::NativeUpdateAnimation(float DeltaSeconds)
+{
+	Super::NativeUpdateAnimation(DeltaSeconds);
+
+	const ALyraCharacter* Character = Cast<ALyraCharacter>(GetOwningActor());
+	if (!Character)
+	{
+		return;
+	}
+
+	ULyraCharacterMovementComponent* CharMoveComp = CastChecked<ULyraCharacterMovementComponent>(Character->GetCharacterMovement());
+	const FLyraCharacterGroundInfo& GroundInfo = CharMoveComp->GetGroundInfo();
+	GroundDistance = GroundInfo.GroundDistance;
+}
+

LyraStarterGame/Source/LyraGame/Animation/LyraAnimInstance.h

@@ -0,0 +1,46 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Animation/AnimInstance.h"
+#include "GameplayEffectTypes.h"
+#include "LyraAnimInstance.generated.h"
+
+class UAbilitySystemComponent;
+
+
+/**
+ * ULyraAnimInstance
+ *
+ *	The base game animation instance class used by this project.
+ */
+UCLASS(Config = Game)
+class ULyraAnimInstance : public UAnimInstance
+{
+	GENERATED_BODY()
+
+public:
+
+	ULyraAnimInstance(const FObjectInitializer& ObjectInitializer);
+
+	virtual void InitializeWithAbilitySystem(UAbilitySystemComponent* ASC);
+
+protected:
+
+#if WITH_EDITOR
+	virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context) const override;
+#endif // WITH_EDITOR
+
+	virtual void NativeInitializeAnimation() override;
+	virtual void NativeUpdateAnimation(float DeltaSeconds) override;
+
+protected:
+
+	// Gameplay tags that can be mapped to blueprint variables. The variables will automatically update as the tags are added or removed.
+	// These should be used instead of manually querying for the gameplay tags.
+	UPROPERTY(EditDefaultsOnly, Category = "GameplayTags")
+	FGameplayTagBlueprintPropertyMap GameplayTagPropertyMap;
+
+	UPROPERTY(BlueprintReadOnly, Category = "Character State Data")
+	float GroundDistance = -1.0f;
+};

LyraStarterGame/Source/LyraGame/Audio/LyraAudioMixEffectsSubsystem.cpp

@@ -0,0 +1,353 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "Audio/LyraAudioMixEffectsSubsystem.h"
+
+#include "AudioMixerBlueprintLibrary.h"
+#include "AudioModulationStatics.h"
+#include "Engine/GameInstance.h"
+#include "Engine/World.h"
+#include "LoadingScreenManager.h"
+#include "LyraAudioSettings.h"
+#include "Settings/LyraSettingsLocal.h"
+#include "Sound/SoundEffectSubmix.h"
+#include "SoundControlBus.h"
+#include "SoundControlBusMix.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraAudioMixEffectsSubsystem)
+
+class FSubsystemCollectionBase;
+
+void ULyraAudioMixEffectsSubsystem::Initialize(FSubsystemCollectionBase& Collection)
+{
+	Super::Initialize(Collection);
+}
+
+void ULyraAudioMixEffectsSubsystem::Deinitialize()
+{
+	if (ULoadingScreenManager* LoadingScreenManager = UGameInstance::GetSubsystem<ULoadingScreenManager>(GetWorld()->GetGameInstance()))
+	{
+		LoadingScreenManager->OnLoadingScreenVisibilityChangedDelegate().RemoveAll(this);
+		ApplyOrRemoveLoadingScreenMix(false);
+	}
+
+	Super::Deinitialize();
+}
+
+bool ULyraAudioMixEffectsSubsystem::ShouldCreateSubsystem(UObject* Outer) const
+{
+	bool bShouldCreateSubsystem = Super::ShouldCreateSubsystem(Outer);
+
+	if (Outer)
+	{
+		if (UWorld* World = Outer->GetWorld())
+		{
+			bShouldCreateSubsystem = DoesSupportWorldType(World->WorldType) && bShouldCreateSubsystem;
+		}
+	}
+
+	return bShouldCreateSubsystem;
+}
+
+void ULyraAudioMixEffectsSubsystem::PostInitialize()
+{
+	if (const ULyraAudioSettings* LyraAudioSettings = GetDefault<ULyraAudioSettings>())
+	{
+		if (UObject* ObjPath = LyraAudioSettings->DefaultControlBusMix.TryLoad())
+		{
+			if (USoundControlBusMix* SoundControlBusMix = Cast<USoundControlBusMix>(ObjPath))
+			{
+				DefaultBaseMix = SoundControlBusMix;
+			}
+			else
+			{
+				ensureMsgf(SoundControlBusMix, TEXT("Default Control Bus Mix reference missing from Lyra Audio Settings."));
+			}
+		}
+
+		if (UObject* ObjPath = LyraAudioSettings->LoadingScreenControlBusMix.TryLoad())
+		{
+			if (USoundControlBusMix* SoundControlBusMix = Cast<USoundControlBusMix>(ObjPath))
+			{
+				LoadingScreenMix = SoundControlBusMix;
+			}
+			else
+			{
+				ensureMsgf(SoundControlBusMix, TEXT("Loading Screen Control Bus Mix reference missing from Lyra Audio Settings."));
+			}
+		}
+
+		if (UObject* ObjPath = LyraAudioSettings->UserSettingsControlBusMix.TryLoad())
+		{
+			if (USoundControlBusMix* SoundControlBusMix = Cast<USoundControlBusMix>(ObjPath))
+			{
+				UserMix = SoundControlBusMix;
+			}
+			else
+			{
+				ensureMsgf(SoundControlBusMix, TEXT("User Control Bus Mix reference missing from Lyra Audio Settings."));
+			}
+		}
+
+		if (UObject* ObjPath = LyraAudioSettings->OverallVolumeControlBus.TryLoad())
+		{
+			if (USoundControlBus* SoundControlBus = Cast<USoundControlBus>(ObjPath))
+			{
+				OverallControlBus = SoundControlBus;
+			}
+			else
+			{
+				ensureMsgf(SoundControlBus, TEXT("Overall Control Bus reference missing from Lyra Audio Settings."));
+			}
+		}
+
+		if (UObject* ObjPath = LyraAudioSettings->MusicVolumeControlBus.TryLoad())
+		{
+			if (USoundControlBus* SoundControlBus = Cast<USoundControlBus>(ObjPath))
+			{
+				MusicControlBus = SoundControlBus;
+			}
+			else
+			{
+				ensureMsgf(SoundControlBus, TEXT("Music Control Bus reference missing from Lyra Audio Settings."));
+			}
+		}
+
+		if (UObject* ObjPath = LyraAudioSettings->SoundFXVolumeControlBus.TryLoad())
+		{
+			if (USoundControlBus* SoundControlBus = Cast<USoundControlBus>(ObjPath))
+			{
+				SoundFXControlBus = SoundControlBus;
+			}
+			else
+			{
+				ensureMsgf(SoundControlBus, TEXT("SoundFX Control Bus reference missing from Lyra Audio Settings."));
+			}
+		}
+
+		if (UObject* ObjPath = LyraAudioSettings->DialogueVolumeControlBus.TryLoad())
+		{
+			if (USoundControlBus* SoundControlBus = Cast<USoundControlBus>(ObjPath))
+			{
+				DialogueControlBus = SoundControlBus;
+			}
+			else
+			{
+				ensureMsgf(SoundControlBus, TEXT("Dialogue Control Bus reference missing from Lyra Audio Settings."));
+			}
+		}
+
+		if (UObject* ObjPath = LyraAudioSettings->VoiceChatVolumeControlBus.TryLoad())
+		{
+			if (USoundControlBus* SoundControlBus = Cast<USoundControlBus>(ObjPath))
+			{
+				VoiceChatControlBus = SoundControlBus;
+			}
+			else
+			{
+				ensureMsgf(SoundControlBus, TEXT("VoiceChat Control Bus reference missing from Lyra Audio Settings."));
+			}
+		}
+
+		// Load HDR Submix Effect Chain
+		for (const FLyraSubmixEffectChainMap& SoftSubmixEffectChain : LyraAudioSettings->HDRAudioSubmixEffectChain)
+		{
+			FLyraAudioSubmixEffectsChain NewEffectChain;
+
+			if (UObject* SubmixObjPath = SoftSubmixEffectChain.Submix.LoadSynchronous())
+			{
+				if (USoundSubmix* Submix = Cast<USoundSubmix>(SubmixObjPath))
+				{
+					NewEffectChain.Submix = Submix;
+					TArray<USoundEffectSubmixPreset*> NewPresetChain;
+
+					for (const TSoftObjectPtr<USoundEffectSubmixPreset>& SoftEffect : SoftSubmixEffectChain.SubmixEffectChain)
+					{
+						if (UObject* EffectObjPath = SoftEffect.LoadSynchronous())
+						{
+							if (USoundEffectSubmixPreset* SubmixPreset = Cast<USoundEffectSubmixPreset>(EffectObjPath))
+							{
+								NewPresetChain.Add(SubmixPreset);
+							}
+						}
+					}
+
+					NewEffectChain.SubmixEffectChain.Append(NewPresetChain);
+				}
+			}
+
+			HDRSubmixEffectChain.Add(NewEffectChain);
+		}
+
+		// Load LDR Submix Effect Chain
+		for (const FLyraSubmixEffectChainMap& SoftSubmixEffectChain : LyraAudioSettings->LDRAudioSubmixEffectChain)
+		{
+			FLyraAudioSubmixEffectsChain NewEffectChain;
+
+			if (UObject* SubmixObjPath = SoftSubmixEffectChain.Submix.LoadSynchronous())
+			{
+				if (USoundSubmix* Submix = Cast<USoundSubmix>(SubmixObjPath))
+				{
+					NewEffectChain.Submix = Submix;
+					TArray<USoundEffectSubmixPreset*> NewPresetChain;
+
+					for (const TSoftObjectPtr<USoundEffectSubmixPreset>& SoftEffect : SoftSubmixEffectChain.SubmixEffectChain)
+					{
+						if (UObject* EffectObjPath = SoftEffect.LoadSynchronous())
+						{
+							if (USoundEffectSubmixPreset* SubmixPreset = Cast<USoundEffectSubmixPreset>(EffectObjPath))
+							{
+								NewPresetChain.Add(SubmixPreset);
+							}
+						}
+					}
+
+					NewEffectChain.SubmixEffectChain.Append(NewPresetChain);
+				}
+			}
+
+			LDRSubmixEffectChain.Add(NewEffectChain);
+		}
+	}
+
+	// Register with the loading screen manager
+	if (ULoadingScreenManager* LoadingScreenManager = UGameInstance::GetSubsystem<ULoadingScreenManager>(GetWorld()->GetGameInstance()))
+	{
+		LoadingScreenManager->OnLoadingScreenVisibilityChangedDelegate().AddUObject(this, &ThisClass::OnLoadingScreenStatusChanged);
+		ApplyOrRemoveLoadingScreenMix(LoadingScreenManager->GetLoadingScreenDisplayStatus());
+	}
+}
+
+void ULyraAudioMixEffectsSubsystem::OnWorldBeginPlay(UWorld& InWorld)
+{
+	if (const UWorld* World = InWorld.GetWorld())
+	{
+		// Activate the default base mix
+		if (DefaultBaseMix)
+		{
+			UAudioModulationStatics::ActivateBusMix(World, DefaultBaseMix);
+		}
+
+		// Retrieve the user settings
+		if (const ULyraSettingsLocal* LyraSettingsLocal = GetDefault<ULyraSettingsLocal>())
+		{
+			// Activate the User Mix
+			if (UserMix)
+			{
+				UAudioModulationStatics::ActivateBusMix(World, UserMix);
+
+				if (OverallControlBus && MusicControlBus && SoundFXControlBus && DialogueControlBus && VoiceChatControlBus)
+				{
+					const FSoundControlBusMixStage OverallControlBusMixStage = UAudioModulationStatics::CreateBusMixStage(World, OverallControlBus, LyraSettingsLocal->GetOverallVolume());
+					const FSoundControlBusMixStage MusicControlBusMixStage = UAudioModulationStatics::CreateBusMixStage(World, MusicControlBus, LyraSettingsLocal->GetMusicVolume());
+					const FSoundControlBusMixStage SoundFXControlBusMixStage = UAudioModulationStatics::CreateBusMixStage(World, SoundFXControlBus, LyraSettingsLocal->GetSoundFXVolume());
+					const FSoundControlBusMixStage DialogueControlBusMixStage = UAudioModulationStatics::CreateBusMixStage(World, DialogueControlBus, LyraSettingsLocal->GetDialogueVolume());
+					const FSoundControlBusMixStage VoiceChatControlBusMixStage = UAudioModulationStatics::CreateBusMixStage(World, VoiceChatControlBus, LyraSettingsLocal->GetVoiceChatVolume());
+
+					TArray<FSoundControlBusMixStage> ControlBusMixStageArray;
+					ControlBusMixStageArray.Add(OverallControlBusMixStage);
+					ControlBusMixStageArray.Add(MusicControlBusMixStage);
+					ControlBusMixStageArray.Add(SoundFXControlBusMixStage);
+					ControlBusMixStageArray.Add(DialogueControlBusMixStage);
+					ControlBusMixStageArray.Add(VoiceChatControlBusMixStage);
+
+					UAudioModulationStatics::UpdateMix(World, UserMix, ControlBusMixStageArray);
+				}
+			}
+
+			ApplyDynamicRangeEffectsChains(LyraSettingsLocal->IsHDRAudioModeEnabled());
+		}
+	}
+}
+
+void ULyraAudioMixEffectsSubsystem::ApplyDynamicRangeEffectsChains(bool bHDRAudio)
+{
+	TArray<FLyraAudioSubmixEffectsChain> AudioSubmixEffectsChainToApply;
+	TArray<FLyraAudioSubmixEffectsChain> AudioSubmixEffectsChainToClear;
+
+	// If HDR Audio is selected, then we clear out any existing LDR Submix Effect Chain Overrides
+	// otherwise the reverse is the case.
+	if (bHDRAudio)
+	{
+		AudioSubmixEffectsChainToApply.Append(HDRSubmixEffectChain);
+		AudioSubmixEffectsChainToClear.Append(LDRSubmixEffectChain);
+	}
+	else
+	{
+		AudioSubmixEffectsChainToApply.Append(LDRSubmixEffectChain);
+		AudioSubmixEffectsChainToClear.Append(HDRSubmixEffectChain);
+	}
+
+	// We want to collect just the submixes we need to actually clear, otherwise they'll be overridden by the new settings
+	TArray<USoundSubmix*> SubmixesLeftToClear;
+
+	// We want to get the submixes that are not being overridden by the new effect chains, so we can clear those out separately
+	for (const FLyraAudioSubmixEffectsChain& EffectChainToClear : AudioSubmixEffectsChainToClear)
+	{
+		bool bAddToList = true;
+
+		for (const FLyraAudioSubmixEffectsChain& SubmixEffectChain : AudioSubmixEffectsChainToApply)
+		{
+			if (SubmixEffectChain.Submix == EffectChainToClear.Submix)
+			{
+				bAddToList = false;
+
+				break;
+			}
+		}
+
+		if (bAddToList)
+		{
+			SubmixesLeftToClear.Add(EffectChainToClear.Submix);
+		}
+	}
+
+
+	// Override submixes
+	for (const FLyraAudioSubmixEffectsChain& SubmixEffectChain : AudioSubmixEffectsChainToApply)
+	{
+		if (SubmixEffectChain.Submix)
+		{
+			UAudioMixerBlueprintLibrary::SetSubmixEffectChainOverride(GetWorld(), SubmixEffectChain.Submix, SubmixEffectChain.SubmixEffectChain, 0.1f);
+
+		}
+	}
+
+	// Clear remaining submixes
+	for (USoundSubmix* Submix : SubmixesLeftToClear)
+	{
+		UAudioMixerBlueprintLibrary::ClearSubmixEffectChainOverride(GetWorld(), Submix, 0.1f);
+	}
+}
+
+void ULyraAudioMixEffectsSubsystem::OnLoadingScreenStatusChanged(bool bShowingLoadingScreen)
+{
+	ApplyOrRemoveLoadingScreenMix(bShowingLoadingScreen);
+}
+
+void ULyraAudioMixEffectsSubsystem::ApplyOrRemoveLoadingScreenMix(bool bWantsLoadingScreenMix)
+{
+	UWorld* World = GetWorld();
+
+	if (bAppliedLoadingScreenMix != bWantsLoadingScreenMix && LoadingScreenMix && World)
+	{
+		if (bWantsLoadingScreenMix)
+		{
+			// Apply the mix
+			UAudioModulationStatics::ActivateBusMix(World, LoadingScreenMix);
+		}
+		else
+		{
+			// Remove the mix
+			UAudioModulationStatics::DeactivateBusMix(World, LoadingScreenMix);
+		}
+		bAppliedLoadingScreenMix = bWantsLoadingScreenMix;
+	}
+}
+
+bool ULyraAudioMixEffectsSubsystem::DoesSupportWorldType(const EWorldType::Type World) const
+{
+	// We only need this subsystem on Game worlds (PIE included)
+	return (World == EWorldType::Game || World == EWorldType::PIE);
+}
+

LyraStarterGame/Source/LyraGame/Audio/LyraAudioMixEffectsSubsystem.h

@@ -0,0 +1,112 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Subsystems/WorldSubsystem.h"
+
+#include "LyraAudioMixEffectsSubsystem.generated.h"
+
+#define UE_API LYRAGAME_API
+
+class FSubsystemCollectionBase;
+class UObject;
+class USoundControlBus;
+class USoundControlBusMix;
+class USoundEffectSubmixPreset;
+class USoundSubmix;
+class UWorld;
+
+USTRUCT()
+struct FLyraAudioSubmixEffectsChain
+{
+	GENERATED_BODY()
+
+	// Submix on which to apply the Submix Effect Chain Override
+	UPROPERTY(Transient)
+	TObjectPtr<USoundSubmix> Submix = nullptr;
+
+	// Submix Effect Chain Override (Effects processed in Array index order)
+	UPROPERTY(Transient)
+	TArray<TObjectPtr<USoundEffectSubmixPreset>> SubmixEffectChain;
+};
+
+/**
+ * This subsystem is meant to automatically engage default and user control bus mixes
+ * to retrieve previously saved user settings and apply them to the activated user mix.
+ * Additionally, this subsystem will automatically apply HDR/LDR Audio Submix Effect Chain Overrides
+ * based on the user's preference for HDR Audio. Submix Effect Chain Overrides are defined in the
+ * Lyra Audio Settings.
+ */
+UCLASS(MinimalAPI)
+class ULyraAudioMixEffectsSubsystem : public UWorldSubsystem
+{
+	GENERATED_BODY()
+
+public:
+	// USubsystem implementation Begin
+	UE_API virtual void Initialize(FSubsystemCollectionBase& Collection) override;
+	UE_API virtual void Deinitialize() override;
+	// USubsystem implementation End
+
+	UE_API virtual bool ShouldCreateSubsystem(UObject* Outer) const override;
+
+	/** Called once all UWorldSubsystems have been initialized */
+	UE_API virtual void PostInitialize() override;
+
+	/** Called when world is ready to start gameplay before the game mode transitions to the correct state and call BeginPlay on all actors */
+	UE_API virtual void OnWorldBeginPlay(UWorld& InWorld) override;
+
+	/** Set whether the HDR Audio Submix Effect Chain Override settings are applied */
+	UE_API void ApplyDynamicRangeEffectsChains(bool bHDRAudio);
+	
+protected:
+	UE_API void OnLoadingScreenStatusChanged(bool bShowingLoadingScreen);
+	UE_API void ApplyOrRemoveLoadingScreenMix(bool bWantsLoadingScreenMix);
+	
+	// Called when determining whether to create this Subsystem
+	UE_API virtual bool DoesSupportWorldType(const EWorldType::Type WorldType) const override;
+
+	// Default Sound Control Bus Mix retrieved from the Lyra Audio Settings
+	UPROPERTY(Transient)
+	TObjectPtr<USoundControlBusMix> DefaultBaseMix = nullptr;
+
+	// Loading Screen Sound Control Bus Mix retrieved from the Lyra Audio Settings
+	UPROPERTY(Transient)
+	TObjectPtr<USoundControlBusMix> LoadingScreenMix = nullptr;
+
+	// User Sound Control Bus Mix retrieved from the Lyra Audio Settings
+	UPROPERTY(Transient)
+	TObjectPtr<USoundControlBusMix> UserMix = nullptr;
+
+	// Overall Sound Control Bus retrieved from the Lyra Audio Settings and linked to the UI and game settings in LyraSettingsLocal
+	UPROPERTY(Transient)
+	TObjectPtr<USoundControlBus> OverallControlBus = nullptr;
+
+	// Music Sound Control Bus retrieved from the Lyra Audio Settings and linked to the UI and game settings in LyraSettingsLocal
+	UPROPERTY(Transient)
+	TObjectPtr<USoundControlBus> MusicControlBus = nullptr;
+
+	// SoundFX Sound Control Bus retrieved from the Lyra Audio Settings and linked to the UI and game settings in LyraSettingsLocal
+	UPROPERTY(Transient)
+	TObjectPtr<USoundControlBus> SoundFXControlBus = nullptr;
+
+	// Dialogue Sound Control Bus retrieved from the Lyra Audio Settings and linked to the UI and game settings in LyraSettingsLocal
+	UPROPERTY(Transient)
+	TObjectPtr<USoundControlBus> DialogueControlBus = nullptr;
+
+	// VoiceChat Sound Control Bus retrieved from the Lyra Audio Settings and linked to the UI and game settings in LyraSettingsLocal
+	UPROPERTY(Transient)
+	TObjectPtr<USoundControlBus> VoiceChatControlBus = nullptr;
+
+	// Submix Effect Chain Overrides to apply when HDR Audio is turned on
+	UPROPERTY(Transient)
+	TArray<FLyraAudioSubmixEffectsChain> HDRSubmixEffectChain;
+
+	// Submix Effect hain Overrides to apply when HDR Audio is turned off
+	UPROPERTY(Transient)
+	TArray<FLyraAudioSubmixEffectsChain> LDRSubmixEffectChain;
+
+	bool bAppliedLoadingScreenMix = false;
+};
+
+#undef UE_API

LyraStarterGame/Source/LyraGame/Audio/LyraAudioSettings.cpp

@@ -0,0 +1,8 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+
+#include "Audio/LyraAudioSettings.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraAudioSettings)
+
+

LyraStarterGame/Source/LyraGame/Audio/LyraAudioSettings.h

@@ -0,0 +1,80 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Engine/DeveloperSettings.h"
+#include "UObject/SoftObjectPtr.h"
+
+#include "LyraAudioSettings.generated.h"
+
+class UObject;
+class USoundEffectSubmixPreset;
+class USoundSubmix;
+
+USTRUCT()
+struct FLyraSubmixEffectChainMap
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, meta = (AllowedClasses = "/Script/Engine.SoundSubmix"))
+	TSoftObjectPtr<USoundSubmix> Submix = nullptr;
+
+	UPROPERTY(EditAnywhere, meta = (AllowedClasses = "/Script/Engine.SoundEffectSubmixPreset"))
+	TArray<TSoftObjectPtr<USoundEffectSubmixPreset>> SubmixEffectChain;
+
+};
+
+/**
+ * 
+ */
+UCLASS(MinimalAPI, config = Game, defaultconfig, meta = (DisplayName = "LyraAudioSettings"))
+class ULyraAudioSettings : public UDeveloperSettings
+{
+	GENERATED_BODY()
+
+public:
+
+	/** The Default Base Control Bus Mix */
+	UPROPERTY(config, EditAnywhere, Category = MixSettings, meta = (AllowedClasses = "/Script/AudioModulation.SoundControlBusMix"))
+	FSoftObjectPath DefaultControlBusMix;
+
+	/** The Loading Screen Control Bus Mix - Called during loading screens to cover background audio events */
+	UPROPERTY(config, EditAnywhere, Category = MixSettings, meta = (AllowedClasses = "/Script/AudioModulation.SoundControlBusMix"))
+	FSoftObjectPath LoadingScreenControlBusMix;
+
+	/** The Default Base Control Bus Mix */
+	UPROPERTY(config, EditAnywhere, Category = UserMixSettings, meta = (AllowedClasses = "/Script/AudioModulation.SoundControlBusMix"))
+	FSoftObjectPath UserSettingsControlBusMix;
+
+	/** Control Bus assigned to the Overall sound volume setting */
+	UPROPERTY(config, EditAnywhere, Category = UserMixSettings, meta = (AllowedClasses = "/Script/AudioModulation.SoundControlBus"))
+	FSoftObjectPath OverallVolumeControlBus;
+
+	/** Control Bus assigned to the Music sound volume setting */
+	UPROPERTY(config, EditAnywhere, Category = UserMixSettings, meta = (AllowedClasses = "/Script/AudioModulation.SoundControlBus"))
+	FSoftObjectPath MusicVolumeControlBus;
+
+	/** Control Bus assigned to the SoundFX sound volume setting */
+	UPROPERTY(config, EditAnywhere, Category = UserMixSettings, meta = (AllowedClasses = "/Script/AudioModulation.SoundControlBus"))
+	FSoftObjectPath SoundFXVolumeControlBus;
+
+	/** Control Bus assigned to the Dialogue sound volume setting */
+	UPROPERTY(config, EditAnywhere, Category = UserMixSettings, meta = (AllowedClasses = "/Script/AudioModulation.SoundControlBus"))
+	FSoftObjectPath DialogueVolumeControlBus;
+
+	/** Control Bus assigned to the VoiceChat sound volume setting */
+	UPROPERTY(config, EditAnywhere, Category = UserMixSettings, meta = (AllowedClasses = "/Script/AudioModulation.SoundControlBus"))
+	FSoftObjectPath VoiceChatVolumeControlBus;
+
+	/** Submix Processing Chains to achieve high dynamic range audio output */
+	UPROPERTY(config, EditAnywhere, Category = EffectSettings)
+	TArray<FLyraSubmixEffectChainMap> HDRAudioSubmixEffectChain;
+	
+	/** Submix Processing Chains to achieve low dynamic range audio output */
+	UPROPERTY(config, EditAnywhere, Category = EffectSettings)
+	TArray<FLyraSubmixEffectChainMap> LDRAudioSubmixEffectChain;
+
+private:
+
+
+};

LyraStarterGame/Source/LyraGame/Camera/LyraCameraAssistInterface.h

@@ -0,0 +1,41 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+
+#include "LyraCameraAssistInterface.generated.h"
+
+/** */
+UINTERFACE(BlueprintType)
+class ULyraCameraAssistInterface : public UInterface
+{
+	GENERATED_BODY()
+};
+
+class ILyraCameraAssistInterface
+{
+	GENERATED_BODY()
+
+public:
+	/**
+	 * Get the list of actors that we're allowing the camera to penetrate. Useful in 3rd person cameras
+	 * when you need the following camera to ignore things like the a collection of view targets, the pawn,
+	 * a vehicle..etc.
+	 */
+	virtual void GetIgnoredActorsForCameraPentration(TArray<const AActor*>& OutActorsAllowPenetration) const { }
+
+	/**
+	 * The target actor to prevent penetration on.  Normally, this is almost always the view target, which if
+	 * unimplemented will remain true.  However, sometimes the view target, isn't the same as the root actor 
+	 * you need to keep in frame.
+	 */
+	virtual TOptional<AActor*> GetCameraPreventPenetrationTarget() const
+	{
+		return TOptional<AActor*>();
+	}
+
+	/** Called if the camera penetrates the focal target.  Useful if you want to hide the target actor when being overlapped. */
+	virtual void OnCameraPenetratingTarget() { }
+};

LyraStarterGame/Source/LyraGame/Camera/LyraCameraComponent.cpp

@@ -0,0 +1,126 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraCameraComponent.h"
+
+#include "Engine/Canvas.h"
+#include "Engine/Engine.h"
+#include "GameFramework/Pawn.h"
+#include "GameFramework/PlayerController.h"
+#include "LyraCameraMode.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraCameraComponent)
+
+
+ULyraCameraComponent::ULyraCameraComponent(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+	CameraModeStack = nullptr;
+	FieldOfViewOffset = 0.0f;
+}
+
+void ULyraCameraComponent::OnRegister()
+{
+	Super::OnRegister();
+
+	if (!CameraModeStack)
+	{
+		CameraModeStack = NewObject<ULyraCameraModeStack>(this);
+		check(CameraModeStack);
+	}
+}
+
+void ULyraCameraComponent::GetCameraView(float DeltaTime, FMinimalViewInfo& DesiredView)
+{
+	check(CameraModeStack);
+
+	UpdateCameraModes();
+
+	FLyraCameraModeView CameraModeView;
+	CameraModeStack->EvaluateStack(DeltaTime, CameraModeView);
+
+	// Keep player controller in sync with the latest view.
+	if (APawn* TargetPawn = Cast<APawn>(GetTargetActor()))
+	{
+		if (APlayerController* PC = TargetPawn->GetController<APlayerController>())
+		{
+			PC->SetControlRotation(CameraModeView.ControlRotation);
+		}
+	}
+
+	// Apply any offset that was added to the field of view.
+	CameraModeView.FieldOfView += FieldOfViewOffset;
+	FieldOfViewOffset = 0.0f;
+
+	// Keep camera component in sync with the latest view.
+	SetWorldLocationAndRotation(CameraModeView.Location, CameraModeView.Rotation);
+	FieldOfView = CameraModeView.FieldOfView;
+
+	// Fill in desired view.
+	DesiredView.Location = CameraModeView.Location;
+	DesiredView.Rotation = CameraModeView.Rotation;
+	DesiredView.FOV = CameraModeView.FieldOfView;
+	DesiredView.OrthoWidth = OrthoWidth;
+	DesiredView.OrthoNearClipPlane = OrthoNearClipPlane;
+	DesiredView.OrthoFarClipPlane = OrthoFarClipPlane;
+	DesiredView.AspectRatio = AspectRatio;
+	DesiredView.bConstrainAspectRatio = bConstrainAspectRatio;
+	DesiredView.bUseFieldOfViewForLOD = bUseFieldOfViewForLOD;
+	DesiredView.ProjectionMode = ProjectionMode;
+
+	// See if the CameraActor wants to override the PostProcess settings used.
+	DesiredView.PostProcessBlendWeight = PostProcessBlendWeight;
+	if (PostProcessBlendWeight > 0.0f)
+	{
+		DesiredView.PostProcessSettings = PostProcessSettings;
+	}
+
+
+	if (IsXRHeadTrackedCamera())
+	{
+		// In XR much of the camera behavior above is irrellevant, but the post process settings are not.
+		Super::GetCameraView(DeltaTime, DesiredView);
+	}
+}
+
+void ULyraCameraComponent::UpdateCameraModes()
+{
+	check(CameraModeStack);
+
+	if (CameraModeStack->IsStackActivate())
+	{
+		if (DetermineCameraModeDelegate.IsBound())
+		{
+			if (const TSubclassOf<ULyraCameraMode> CameraMode = DetermineCameraModeDelegate.Execute())
+			{
+				CameraModeStack->PushCameraMode(CameraMode);
+			}
+		}
+	}
+}
+
+void ULyraCameraComponent::DrawDebug(UCanvas* Canvas) const
+{
+	check(Canvas);
+
+	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
+
+	DisplayDebugManager.SetFont(GEngine->GetSmallFont());
+	DisplayDebugManager.SetDrawColor(FColor::Yellow);
+	DisplayDebugManager.DrawString(FString::Printf(TEXT("LyraCameraComponent: %s"), *GetNameSafe(GetTargetActor())));
+
+	DisplayDebugManager.SetDrawColor(FColor::White);
+	DisplayDebugManager.DrawString(FString::Printf(TEXT("   Location: %s"), *GetComponentLocation().ToCompactString()));
+	DisplayDebugManager.DrawString(FString::Printf(TEXT("   Rotation: %s"), *GetComponentRotation().ToCompactString()));
+	DisplayDebugManager.DrawString(FString::Printf(TEXT("   FOV: %f"), FieldOfView));
+
+	check(CameraModeStack);
+	CameraModeStack->DrawDebug(Canvas);
+}
+
+void ULyraCameraComponent::GetBlendInfo(float& OutWeightOfTopLayer, FGameplayTag& OutTagOfTopLayer) const
+{
+	check(CameraModeStack);
+	CameraModeStack->GetBlendInfo(/*out*/ OutWeightOfTopLayer, /*out*/ OutTagOfTopLayer);
+}
+
+

LyraStarterGame/Source/LyraGame/Camera/LyraCameraComponent.h

@@ -0,0 +1,70 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Camera/CameraComponent.h"
+#include "GameFramework/Actor.h"
+
+#include "LyraCameraComponent.generated.h"
+
+class UCanvas;
+class ULyraCameraMode;
+class ULyraCameraModeStack;
+class UObject;
+struct FFrame;
+struct FGameplayTag;
+struct FMinimalViewInfo;
+template <class TClass> class TSubclassOf;
+
+DECLARE_DELEGATE_RetVal(TSubclassOf<ULyraCameraMode>, FLyraCameraModeDelegate);
+
+
+/**
+ * ULyraCameraComponent
+ *
+ *	The base camera component class used by this project.
+ */
+UCLASS()
+class ULyraCameraComponent : public UCameraComponent
+{
+	GENERATED_BODY()
+
+public:
+
+	ULyraCameraComponent(const FObjectInitializer& ObjectInitializer);
+
+	// Returns the camera component if one exists on the specified actor.
+	UFUNCTION(BlueprintPure, Category = "Lyra|Camera")
+	static ULyraCameraComponent* FindCameraComponent(const AActor* Actor) { return (Actor ? Actor->FindComponentByClass<ULyraCameraComponent>() : nullptr); }
+
+	// Returns the target actor that the camera is looking at.
+	virtual AActor* GetTargetActor() const { return GetOwner(); }
+
+	// Delegate used to query for the best camera mode.
+	FLyraCameraModeDelegate DetermineCameraModeDelegate;
+
+	// Add an offset to the field of view.  The offset is only for one frame, it gets cleared once it is applied.
+	void AddFieldOfViewOffset(float FovOffset) { FieldOfViewOffset += FovOffset; }
+
+	virtual void DrawDebug(UCanvas* Canvas) const;
+
+	// Gets the tag associated with the top layer and the blend weight of it
+	void GetBlendInfo(float& OutWeightOfTopLayer, FGameplayTag& OutTagOfTopLayer) const;
+
+protected:
+
+	virtual void OnRegister() override;
+	virtual void GetCameraView(float DeltaTime, FMinimalViewInfo& DesiredView) override;
+
+	virtual void UpdateCameraModes();
+
+protected:
+
+	// Stack used to blend the camera modes.
+	UPROPERTY()
+	TObjectPtr<ULyraCameraModeStack> CameraModeStack;
+
+	// Offset applied to the field of view.  The offset is only for one frame, it gets cleared once it is applied.
+	float FieldOfViewOffset;
+
+};

LyraStarterGame/Source/LyraGame/Camera/LyraCameraMode.cpp

@@ -0,0 +1,465 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraCameraMode.h"
+
+#include "Components/CapsuleComponent.h"
+#include "Engine/Canvas.h"
+#include "GameFramework/Character.h"
+#include "LyraCameraComponent.h"
+#include "LyraPlayerCameraManager.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraCameraMode)
+
+
+//////////////////////////////////////////////////////////////////////////
+// FLyraCameraModeView
+//////////////////////////////////////////////////////////////////////////
+FLyraCameraModeView::FLyraCameraModeView()
+	: Location(ForceInit)
+	, Rotation(ForceInit)
+	, ControlRotation(ForceInit)
+	, FieldOfView(LYRA_CAMERA_DEFAULT_FOV)
+{
+}
+
+void FLyraCameraModeView::Blend(const FLyraCameraModeView& Other, float OtherWeight)
+{
+	if (OtherWeight <= 0.0f)
+	{
+		return;
+	}
+	else if (OtherWeight >= 1.0f)
+	{
+		*this = Other;
+		return;
+	}
+
+	Location = FMath::Lerp(Location, Other.Location, OtherWeight);
+
+	const FRotator DeltaRotation = (Other.Rotation - Rotation).GetNormalized();
+	Rotation = Rotation + (OtherWeight * DeltaRotation);
+
+	const FRotator DeltaControlRotation = (Other.ControlRotation - ControlRotation).GetNormalized();
+	ControlRotation = ControlRotation + (OtherWeight * DeltaControlRotation);
+
+	FieldOfView = FMath::Lerp(FieldOfView, Other.FieldOfView, OtherWeight);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// ULyraCameraMode
+//////////////////////////////////////////////////////////////////////////
+ULyraCameraMode::ULyraCameraMode()
+{
+	FieldOfView = LYRA_CAMERA_DEFAULT_FOV;
+	ViewPitchMin = LYRA_CAMERA_DEFAULT_PITCH_MIN;
+	ViewPitchMax = LYRA_CAMERA_DEFAULT_PITCH_MAX;
+
+	BlendTime = 0.5f;
+	BlendFunction = ELyraCameraModeBlendFunction::EaseOut;
+	BlendExponent = 4.0f;
+	BlendAlpha = 1.0f;
+	BlendWeight = 1.0f;
+}
+
+ULyraCameraComponent* ULyraCameraMode::GetLyraCameraComponent() const
+{
+	return CastChecked<ULyraCameraComponent>(GetOuter());
+}
+
+UWorld* ULyraCameraMode::GetWorld() const
+{
+	return HasAnyFlags(RF_ClassDefaultObject) ? nullptr : GetOuter()->GetWorld();
+}
+
+AActor* ULyraCameraMode::GetTargetActor() const
+{
+	const ULyraCameraComponent* LyraCameraComponent = GetLyraCameraComponent();
+
+	return LyraCameraComponent->GetTargetActor();
+}
+
+FVector ULyraCameraMode::GetPivotLocation() const
+{
+	const AActor* TargetActor = GetTargetActor();
+	check(TargetActor);
+
+	if (const APawn* TargetPawn = Cast<APawn>(TargetActor))
+	{
+		// Height adjustments for characters to account for crouching.
+		if (const ACharacter* TargetCharacter = Cast<ACharacter>(TargetPawn))
+		{
+			const ACharacter* TargetCharacterCDO = TargetCharacter->GetClass()->GetDefaultObject<ACharacter>();
+			check(TargetCharacterCDO);
+
+			const UCapsuleComponent* CapsuleComp = TargetCharacter->GetCapsuleComponent();
+			check(CapsuleComp);
+
+			const UCapsuleComponent* CapsuleCompCDO = TargetCharacterCDO->GetCapsuleComponent();
+			check(CapsuleCompCDO);
+
+			const float DefaultHalfHeight = CapsuleCompCDO->GetUnscaledCapsuleHalfHeight();
+			const float ActualHalfHeight = CapsuleComp->GetUnscaledCapsuleHalfHeight();
+			const float HeightAdjustment = (DefaultHalfHeight - ActualHalfHeight) + TargetCharacterCDO->BaseEyeHeight;
+
+			return TargetCharacter->GetActorLocation() + (FVector::UpVector * HeightAdjustment);
+		}
+
+		return TargetPawn->GetPawnViewLocation();
+	}
+
+	return TargetActor->GetActorLocation();
+}
+
+FRotator ULyraCameraMode::GetPivotRotation() const
+{
+	const AActor* TargetActor = GetTargetActor();
+	check(TargetActor);
+
+	if (const APawn* TargetPawn = Cast<APawn>(TargetActor))
+	{
+		return TargetPawn->GetViewRotation();
+	}
+
+	return TargetActor->GetActorRotation();
+}
+
+void ULyraCameraMode::UpdateCameraMode(float DeltaTime)
+{
+	UpdateView(DeltaTime);
+	UpdateBlending(DeltaTime);
+}
+
+void ULyraCameraMode::UpdateView(float DeltaTime)
+{
+	FVector PivotLocation = GetPivotLocation();
+	FRotator PivotRotation = GetPivotRotation();
+
+	PivotRotation.Pitch = FMath::ClampAngle(PivotRotation.Pitch, ViewPitchMin, ViewPitchMax);
+
+	View.Location = PivotLocation;
+	View.Rotation = PivotRotation;
+	View.ControlRotation = View.Rotation;
+	View.FieldOfView = FieldOfView;
+}
+
+void ULyraCameraMode::SetBlendWeight(float Weight)
+{
+	BlendWeight = FMath::Clamp(Weight, 0.0f, 1.0f);
+
+	// Since we're setting the blend weight directly, we need to calculate the blend alpha to account for the blend function.
+	const float InvExponent = (BlendExponent > 0.0f) ? (1.0f / BlendExponent) : 1.0f;
+
+	switch (BlendFunction)
+	{
+	case ELyraCameraModeBlendFunction::Linear:
+		BlendAlpha = BlendWeight;
+		break;
+
+	case ELyraCameraModeBlendFunction::EaseIn:
+		BlendAlpha = FMath::InterpEaseIn(0.0f, 1.0f, BlendWeight, InvExponent);
+		break;
+
+	case ELyraCameraModeBlendFunction::EaseOut:
+		BlendAlpha = FMath::InterpEaseOut(0.0f, 1.0f, BlendWeight, InvExponent);
+		break;
+
+	case ELyraCameraModeBlendFunction::EaseInOut:
+		BlendAlpha = FMath::InterpEaseInOut(0.0f, 1.0f, BlendWeight, InvExponent);
+		break;
+
+	default:
+		checkf(false, TEXT("SetBlendWeight: Invalid BlendFunction [%d]\n"), (uint8)BlendFunction);
+		break;
+	}
+}
+
+void ULyraCameraMode::UpdateBlending(float DeltaTime)
+{
+	if (BlendTime > 0.0f)
+	{
+		BlendAlpha += (DeltaTime / BlendTime);
+		BlendAlpha = FMath::Min(BlendAlpha, 1.0f);
+	}
+	else
+	{
+		BlendAlpha = 1.0f;
+	}
+
+	const float Exponent = (BlendExponent > 0.0f) ? BlendExponent : 1.0f;
+
+	switch (BlendFunction)
+	{
+	case ELyraCameraModeBlendFunction::Linear:
+		BlendWeight = BlendAlpha;
+		break;
+
+	case ELyraCameraModeBlendFunction::EaseIn:
+		BlendWeight = FMath::InterpEaseIn(0.0f, 1.0f, BlendAlpha, Exponent);
+		break;
+
+	case ELyraCameraModeBlendFunction::EaseOut:
+		BlendWeight = FMath::InterpEaseOut(0.0f, 1.0f, BlendAlpha, Exponent);
+		break;
+
+	case ELyraCameraModeBlendFunction::EaseInOut:
+		BlendWeight = FMath::InterpEaseInOut(0.0f, 1.0f, BlendAlpha, Exponent);
+		break;
+
+	default:
+		checkf(false, TEXT("UpdateBlending: Invalid BlendFunction [%d]\n"), (uint8)BlendFunction);
+		break;
+	}
+}
+
+void ULyraCameraMode::DrawDebug(UCanvas* Canvas) const
+{
+	check(Canvas);
+
+	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
+
+	DisplayDebugManager.SetDrawColor(FColor::White);
+	DisplayDebugManager.DrawString(FString::Printf(TEXT("      LyraCameraMode: %s (%f)"), *GetName(), BlendWeight));
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// ULyraCameraModeStack
+//////////////////////////////////////////////////////////////////////////
+ULyraCameraModeStack::ULyraCameraModeStack()
+{
+	bIsActive = true;
+}
+
+void ULyraCameraModeStack::ActivateStack()
+{
+	if (!bIsActive)
+	{
+		bIsActive = true;
+
+		// Notify camera modes that they are being activated.
+		for (ULyraCameraMode* CameraMode : CameraModeStack)
+		{
+			check(CameraMode);
+			CameraMode->OnActivation();
+		}
+	}
+}
+
+void ULyraCameraModeStack::DeactivateStack()
+{
+	if (bIsActive)
+	{
+		bIsActive = false;
+
+		// Notify camera modes that they are being deactivated.
+		for (ULyraCameraMode* CameraMode : CameraModeStack)
+		{
+			check(CameraMode);
+			CameraMode->OnDeactivation();
+		}
+	}
+}
+
+void ULyraCameraModeStack::PushCameraMode(TSubclassOf<ULyraCameraMode> CameraModeClass)
+{
+	if (!CameraModeClass)
+	{
+		return;
+	}
+
+	ULyraCameraMode* CameraMode = GetCameraModeInstance(CameraModeClass);
+	check(CameraMode);
+
+	int32 StackSize = CameraModeStack.Num();
+
+	if ((StackSize > 0) && (CameraModeStack[0] == CameraMode))
+	{
+		// Already top of stack.
+		return;
+	}
+
+	// See if it's already in the stack and remove it.
+	// Figure out how much it was contributing to the stack.
+	int32 ExistingStackIndex = INDEX_NONE;
+	float ExistingStackContribution = 1.0f;
+
+	for (int32 StackIndex = 0; StackIndex < StackSize; ++StackIndex)
+	{
+		if (CameraModeStack[StackIndex] == CameraMode)
+		{
+			ExistingStackIndex = StackIndex;
+			ExistingStackContribution *= CameraMode->GetBlendWeight();
+			break;
+		}
+		else
+		{
+			ExistingStackContribution *= (1.0f - CameraModeStack[StackIndex]->GetBlendWeight());
+		}
+	}
+
+	if (ExistingStackIndex != INDEX_NONE)
+	{
+		CameraModeStack.RemoveAt(ExistingStackIndex);
+		StackSize--;
+	}
+	else
+	{
+		ExistingStackContribution = 0.0f;
+	}
+
+	// Decide what initial weight to start with.
+	const bool bShouldBlend = ((CameraMode->GetBlendTime() > 0.0f) && (StackSize > 0));
+	const float BlendWeight = (bShouldBlend ? ExistingStackContribution : 1.0f);
+
+	CameraMode->SetBlendWeight(BlendWeight);
+
+	// Add new entry to top of stack.
+	CameraModeStack.Insert(CameraMode, 0);
+
+	// Make sure stack bottom is always weighted 100%.
+	CameraModeStack.Last()->SetBlendWeight(1.0f);
+
+	// Let the camera mode know if it's being added to the stack.
+	if (ExistingStackIndex == INDEX_NONE)
+	{
+		CameraMode->OnActivation();
+	}
+}
+
+bool ULyraCameraModeStack::EvaluateStack(float DeltaTime, FLyraCameraModeView& OutCameraModeView)
+{
+	if (!bIsActive)
+	{
+		return false;
+	}
+
+	UpdateStack(DeltaTime);
+	BlendStack(OutCameraModeView);
+
+	return true;
+}
+
+ULyraCameraMode* ULyraCameraModeStack::GetCameraModeInstance(TSubclassOf<ULyraCameraMode> CameraModeClass)
+{
+	check(CameraModeClass);
+
+	// First see if we already created one.
+	for (ULyraCameraMode* CameraMode : CameraModeInstances)
+	{
+		if ((CameraMode != nullptr) && (CameraMode->GetClass() == CameraModeClass))
+		{
+			return CameraMode;
+		}
+	}
+
+	// Not found, so we need to create it.
+	ULyraCameraMode* NewCameraMode = NewObject<ULyraCameraMode>(GetOuter(), CameraModeClass, NAME_None, RF_NoFlags);
+	check(NewCameraMode);
+
+	CameraModeInstances.Add(NewCameraMode);
+
+	return NewCameraMode;
+}
+
+void ULyraCameraModeStack::UpdateStack(float DeltaTime)
+{
+	const int32 StackSize = CameraModeStack.Num();
+	if (StackSize <= 0)
+	{
+		return;
+	}
+
+	int32 RemoveCount = 0;
+	int32 RemoveIndex = INDEX_NONE;
+
+	for (int32 StackIndex = 0; StackIndex < StackSize; ++StackIndex)
+	{
+		ULyraCameraMode* CameraMode = CameraModeStack[StackIndex];
+		check(CameraMode);
+
+		CameraMode->UpdateCameraMode(DeltaTime);
+
+		if (CameraMode->GetBlendWeight() >= 1.0f)
+		{
+			// Everything below this mode is now irrelevant and can be removed.
+			RemoveIndex = (StackIndex + 1);
+			RemoveCount = (StackSize - RemoveIndex);
+			break;
+		}
+	}
+
+	if (RemoveCount > 0)
+	{
+		// Let the camera modes know they being removed from the stack.
+		for (int32 StackIndex = RemoveIndex; StackIndex < StackSize; ++StackIndex)
+		{
+			ULyraCameraMode* CameraMode = CameraModeStack[StackIndex];
+			check(CameraMode);
+
+			CameraMode->OnDeactivation();
+		}
+
+		CameraModeStack.RemoveAt(RemoveIndex, RemoveCount);
+	}
+}
+
+void ULyraCameraModeStack::BlendStack(FLyraCameraModeView& OutCameraModeView) const
+{
+	const int32 StackSize = CameraModeStack.Num();
+	if (StackSize <= 0)
+	{
+		return;
+	}
+
+	// Start at the bottom and blend up the stack
+	const ULyraCameraMode* CameraMode = CameraModeStack[StackSize - 1];
+	check(CameraMode);
+
+	OutCameraModeView = CameraMode->GetCameraModeView();
+
+	for (int32 StackIndex = (StackSize - 2); StackIndex >= 0; --StackIndex)
+	{
+		CameraMode = CameraModeStack[StackIndex];
+		check(CameraMode);
+
+		OutCameraModeView.Blend(CameraMode->GetCameraModeView(), CameraMode->GetBlendWeight());
+	}
+}
+
+void ULyraCameraModeStack::DrawDebug(UCanvas* Canvas) const
+{
+	check(Canvas);
+
+	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
+
+	DisplayDebugManager.SetDrawColor(FColor::Green);
+	DisplayDebugManager.DrawString(FString(TEXT("   --- Camera Modes (Begin) ---")));
+
+	for (const ULyraCameraMode* CameraMode : CameraModeStack)
+	{
+		check(CameraMode);
+		CameraMode->DrawDebug(Canvas);
+	}
+
+	DisplayDebugManager.SetDrawColor(FColor::Green);
+	DisplayDebugManager.DrawString(FString::Printf(TEXT("   --- Camera Modes (End) ---")));
+}
+
+void ULyraCameraModeStack::GetBlendInfo(float& OutWeightOfTopLayer, FGameplayTag& OutTagOfTopLayer) const
+{
+	if (CameraModeStack.Num() == 0)
+	{
+		OutWeightOfTopLayer = 1.0f;
+		OutTagOfTopLayer = FGameplayTag();
+		return;
+	}
+	else
+	{
+		ULyraCameraMode* TopEntry = CameraModeStack.Last();
+		check(TopEntry);
+		OutWeightOfTopLayer = TopEntry->GetBlendWeight();
+		OutTagOfTopLayer = TopEntry->GetCameraTypeTag();
+	}
+}
+

LyraStarterGame/Source/LyraGame/Camera/LyraCameraMode.h

@@ -0,0 +1,203 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Engine/World.h"
+#include "GameplayTagContainer.h"
+
+#include "LyraCameraMode.generated.h"
+
+#define UE_API LYRAGAME_API
+
+class AActor;
+class UCanvas;
+class ULyraCameraComponent;
+
+/**
+ * ELyraCameraModeBlendFunction
+ *
+ *	Blend function used for transitioning between camera modes.
+ */
+UENUM(BlueprintType)
+enum class ELyraCameraModeBlendFunction : uint8
+{
+	// Does a simple linear interpolation.
+	Linear,
+
+	// Immediately accelerates, but smoothly decelerates into the target.  Ease amount controlled by the exponent.
+	EaseIn,
+
+	// Smoothly accelerates, but does not decelerate into the target.  Ease amount controlled by the exponent.
+	EaseOut,
+
+	// Smoothly accelerates and decelerates.  Ease amount controlled by the exponent.
+	EaseInOut,
+
+	COUNT	UMETA(Hidden)
+};
+
+
+/**
+ * FLyraCameraModeView
+ *
+ *	View data produced by the camera mode that is used to blend camera modes.
+ */
+struct FLyraCameraModeView
+{
+public:
+
+	FLyraCameraModeView();
+
+	void Blend(const FLyraCameraModeView& Other, float OtherWeight);
+
+public:
+
+	FVector Location;
+	FRotator Rotation;
+	FRotator ControlRotation;
+	float FieldOfView;
+};
+
+
+/**
+ * ULyraCameraMode
+ *
+ *	Base class for all camera modes.
+ */
+UCLASS(MinimalAPI, Abstract, NotBlueprintable)
+class ULyraCameraMode : public UObject
+{
+	GENERATED_BODY()
+
+public:
+
+	UE_API ULyraCameraMode();
+
+	UE_API ULyraCameraComponent* GetLyraCameraComponent() const;
+
+	UE_API virtual UWorld* GetWorld() const override;
+
+	UE_API AActor* GetTargetActor() const;
+
+	const FLyraCameraModeView& GetCameraModeView() const { return View; }
+
+	// Called when this camera mode is activated on the camera mode stack.
+	virtual void OnActivation() {};
+
+	// Called when this camera mode is deactivated on the camera mode stack.
+	virtual void OnDeactivation() {};
+
+	UE_API void UpdateCameraMode(float DeltaTime);
+
+	float GetBlendTime() const { return BlendTime; }
+	float GetBlendWeight() const { return BlendWeight; }
+	UE_API void SetBlendWeight(float Weight);
+
+	FGameplayTag GetCameraTypeTag() const
+	{
+		return CameraTypeTag;
+	}
+
+	UE_API virtual void DrawDebug(UCanvas* Canvas) const;
+
+protected:
+
+	UE_API virtual FVector GetPivotLocation() const;
+	UE_API virtual FRotator GetPivotRotation() const;
+
+	UE_API virtual void UpdateView(float DeltaTime);
+	UE_API virtual void UpdateBlending(float DeltaTime);
+
+protected:
+	// A tag that can be queried by gameplay code that cares when a kind of camera mode is active
+	// without having to ask about a specific mode (e.g., when aiming downsights to get more accuracy)
+	UPROPERTY(EditDefaultsOnly, Category = "Blending")
+	FGameplayTag CameraTypeTag;
+
+	// View output produced by the camera mode.
+	FLyraCameraModeView View;
+
+	// The horizontal field of view (in degrees).
+	UPROPERTY(EditDefaultsOnly, Category = "View", Meta = (UIMin = "5.0", UIMax = "170", ClampMin = "5.0", ClampMax = "170.0"))
+	float FieldOfView;
+
+	// Minimum view pitch (in degrees).
+	UPROPERTY(EditDefaultsOnly, Category = "View", Meta = (UIMin = "-89.9", UIMax = "89.9", ClampMin = "-89.9", ClampMax = "89.9"))
+	float ViewPitchMin;
+
+	// Maximum view pitch (in degrees).
+	UPROPERTY(EditDefaultsOnly, Category = "View", Meta = (UIMin = "-89.9", UIMax = "89.9", ClampMin = "-89.9", ClampMax = "89.9"))
+	float ViewPitchMax;
+
+	// How long it takes to blend in this mode.
+	UPROPERTY(EditDefaultsOnly, Category = "Blending")
+	float BlendTime;
+
+	// Function used for blending.
+	UPROPERTY(EditDefaultsOnly, Category = "Blending")
+	ELyraCameraModeBlendFunction BlendFunction;
+
+	// Exponent used by blend functions to control the shape of the curve.
+	UPROPERTY(EditDefaultsOnly, Category = "Blending")
+	float BlendExponent;
+
+	// Linear blend alpha used to determine the blend weight.
+	float BlendAlpha;
+
+	// Blend weight calculated using the blend alpha and function.
+	float BlendWeight;
+
+protected:
+	/** If true, skips all interpolation and puts camera in ideal location.  Automatically set to false next frame. */
+	UPROPERTY(transient)
+	uint32 bResetInterpolation:1;
+};
+
+
+/**
+ * ULyraCameraModeStack
+ *
+ *	Stack used for blending camera modes.
+ */
+UCLASS()
+class ULyraCameraModeStack : public UObject
+{
+	GENERATED_BODY()
+
+public:
+
+	ULyraCameraModeStack();
+
+	void ActivateStack();
+	void DeactivateStack();
+
+	bool IsStackActivate() const { return bIsActive; }
+
+	void PushCameraMode(TSubclassOf<ULyraCameraMode> CameraModeClass);
+
+	bool EvaluateStack(float DeltaTime, FLyraCameraModeView& OutCameraModeView);
+
+	void DrawDebug(UCanvas* Canvas) const;
+
+	// Gets the tag associated with the top layer and the blend weight of it
+	void GetBlendInfo(float& OutWeightOfTopLayer, FGameplayTag& OutTagOfTopLayer) const;
+
+protected:
+
+	ULyraCameraMode* GetCameraModeInstance(TSubclassOf<ULyraCameraMode> CameraModeClass);
+
+	void UpdateStack(float DeltaTime);
+	void BlendStack(FLyraCameraModeView& OutCameraModeView) const;
+
+protected:
+
+	bool bIsActive;
+
+	UPROPERTY()
+	TArray<TObjectPtr<ULyraCameraMode>> CameraModeInstances;
+
+	UPROPERTY()
+	TArray<TObjectPtr<ULyraCameraMode>> CameraModeStack;
+};
+
+#undef UE_API

LyraStarterGame/Source/LyraGame/Camera/LyraCameraMode_ThirdPerson.cpp

@@ -0,0 +1,373 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraCameraMode_ThirdPerson.h"
+#include "Camera/LyraCameraMode.h"
+#include "Components/PrimitiveComponent.h"
+#include "Camera/LyraPenetrationAvoidanceFeeler.h"
+#include "Curves/CurveVector.h"
+#include "Engine/Canvas.h"
+#include "GameFramework/CameraBlockingVolume.h"
+#include "LyraCameraAssistInterface.h"
+#include "GameFramework/Controller.h"
+#include "GameFramework/Character.h"
+#include "Math/RotationMatrix.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraCameraMode_ThirdPerson)
+
+namespace LyraCameraMode_ThirdPerson_Statics
+{
+	static const FName NAME_IgnoreCameraCollision = TEXT("IgnoreCameraCollision");
+}
+
+ULyraCameraMode_ThirdPerson::ULyraCameraMode_ThirdPerson()
+{
+	TargetOffsetCurve = nullptr;
+
+	PenetrationAvoidanceFeelers.Add(FLyraPenetrationAvoidanceFeeler(FRotator(+00.0f, +00.0f, 0.0f), 1.00f, 1.00f, 14.f, 0));
+	PenetrationAvoidanceFeelers.Add(FLyraPenetrationAvoidanceFeeler(FRotator(+00.0f, +16.0f, 0.0f), 0.75f, 0.75f, 00.f, 3));
+	PenetrationAvoidanceFeelers.Add(FLyraPenetrationAvoidanceFeeler(FRotator(+00.0f, -16.0f, 0.0f), 0.75f, 0.75f, 00.f, 3));
+	PenetrationAvoidanceFeelers.Add(FLyraPenetrationAvoidanceFeeler(FRotator(+00.0f, +32.0f, 0.0f), 0.50f, 0.50f, 00.f, 5));
+	PenetrationAvoidanceFeelers.Add(FLyraPenetrationAvoidanceFeeler(FRotator(+00.0f, -32.0f, 0.0f), 0.50f, 0.50f, 00.f, 5));
+	PenetrationAvoidanceFeelers.Add(FLyraPenetrationAvoidanceFeeler(FRotator(+20.0f, +00.0f, 0.0f), 1.00f, 1.00f, 00.f, 4));
+	PenetrationAvoidanceFeelers.Add(FLyraPenetrationAvoidanceFeeler(FRotator(-20.0f, +00.0f, 0.0f), 0.50f, 0.50f, 00.f, 4));
+}
+
+void ULyraCameraMode_ThirdPerson::UpdateView(float DeltaTime)
+{
+	UpdateForTarget(DeltaTime);
+	UpdateCrouchOffset(DeltaTime);
+
+	FVector PivotLocation = GetPivotLocation() + CurrentCrouchOffset;
+	FRotator PivotRotation = GetPivotRotation();
+
+	PivotRotation.Pitch = FMath::ClampAngle(PivotRotation.Pitch, ViewPitchMin, ViewPitchMax);
+
+	View.Location = PivotLocation;
+	View.Rotation = PivotRotation;
+	View.ControlRotation = View.Rotation;
+	View.FieldOfView = FieldOfView;
+
+	// Apply third person offset using pitch.
+	if (!bUseRuntimeFloatCurves)
+	{
+		if (TargetOffsetCurve)
+		{
+			const FVector TargetOffset = TargetOffsetCurve->GetVectorValue(PivotRotation.Pitch);
+			View.Location = PivotLocation + PivotRotation.RotateVector(TargetOffset);
+		}
+	}
+	else
+	{
+		FVector TargetOffset(0.0f);
+
+		TargetOffset.X = TargetOffsetX.GetRichCurveConst()->Eval(PivotRotation.Pitch);
+		TargetOffset.Y = TargetOffsetY.GetRichCurveConst()->Eval(PivotRotation.Pitch);
+		TargetOffset.Z = TargetOffsetZ.GetRichCurveConst()->Eval(PivotRotation.Pitch);
+
+		View.Location = PivotLocation + PivotRotation.RotateVector(TargetOffset);
+	}
+
+	// Adjust final desired camera location to prevent any penetration
+	UpdatePreventPenetration(DeltaTime);
+}
+
+void ULyraCameraMode_ThirdPerson::UpdateForTarget(float DeltaTime)
+{
+
+	if (const ACharacter* TargetCharacter = Cast<ACharacter>(GetTargetActor()))
+	{
+		if (TargetCharacter->IsCrouched())
+		{
+			const ACharacter* TargetCharacterCDO = TargetCharacter->GetClass()->GetDefaultObject<ACharacter>();
+			const float CrouchedHeightAdjustment = TargetCharacterCDO->CrouchedEyeHeight - TargetCharacterCDO->BaseEyeHeight;
+
+			SetTargetCrouchOffset(FVector(0.f, 0.f, CrouchedHeightAdjustment));
+
+			return;
+		}
+	}
+
+	SetTargetCrouchOffset(FVector::ZeroVector);
+}
+
+void ULyraCameraMode_ThirdPerson::DrawDebug(UCanvas* Canvas) const
+{
+	Super::DrawDebug(Canvas);
+
+#if ENABLE_DRAW_DEBUG
+	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
+	for (int i = 0; i < DebugActorsHitDuringCameraPenetration.Num(); i++)
+	{
+		DisplayDebugManager.DrawString(
+			FString::Printf(TEXT("HitActorDuringPenetration[%d]: %s")
+				, i
+				, *DebugActorsHitDuringCameraPenetration[i]->GetName()));
+	}
+
+	LastDrawDebugTime = GetWorld()->GetTimeSeconds();
+#endif
+}
+
+void ULyraCameraMode_ThirdPerson::UpdatePreventPenetration(float DeltaTime)
+{
+	if (!bPreventPenetration)
+	{
+		return;
+	}
+
+	AActor* TargetActor = GetTargetActor();
+
+	APawn* TargetPawn = Cast<APawn>(TargetActor);
+	AController* TargetController = TargetPawn ? TargetPawn->GetController() : nullptr;
+	ILyraCameraAssistInterface* TargetControllerAssist = Cast<ILyraCameraAssistInterface>(TargetController);
+
+	ILyraCameraAssistInterface* TargetActorAssist = Cast<ILyraCameraAssistInterface>(TargetActor);
+
+	TOptional<AActor*> OptionalPPTarget = TargetActorAssist ? TargetActorAssist->GetCameraPreventPenetrationTarget() : TOptional<AActor*>();
+	AActor* PPActor = OptionalPPTarget.IsSet() ? OptionalPPTarget.GetValue() : TargetActor;
+	ILyraCameraAssistInterface* PPActorAssist = OptionalPPTarget.IsSet() ? Cast<ILyraCameraAssistInterface>(PPActor) : nullptr;
+
+	const UPrimitiveComponent* PPActorRootComponent = Cast<UPrimitiveComponent>(PPActor->GetRootComponent());
+	if (PPActorRootComponent)
+	{
+		// Attempt at picking SafeLocation automatically, so we reduce camera translation when aiming.
+		// Our camera is our reticle, so we want to preserve our aim and keep that as steady and smooth as possible.
+		// Pick closest point on capsule to our aim line.
+		FVector ClosestPointOnLineToCapsuleCenter;
+		FVector SafeLocation = PPActor->GetActorLocation();
+		FMath::PointDistToLine(SafeLocation, View.Rotation.Vector(), View.Location, ClosestPointOnLineToCapsuleCenter);
+
+		// Adjust Safe distance height to be same as aim line, but within capsule.
+		float const PushInDistance = PenetrationAvoidanceFeelers[0].Extent + CollisionPushOutDistance;
+		float const MaxHalfHeight = PPActor->GetSimpleCollisionHalfHeight() - PushInDistance;
+		SafeLocation.Z = FMath::Clamp(ClosestPointOnLineToCapsuleCenter.Z, SafeLocation.Z - MaxHalfHeight, SafeLocation.Z + MaxHalfHeight);
+
+		float DistanceSqr;
+		PPActorRootComponent->GetSquaredDistanceToCollision(ClosestPointOnLineToCapsuleCenter, DistanceSqr, SafeLocation);
+		// Push back inside capsule to avoid initial penetration when doing line checks.
+		if (PenetrationAvoidanceFeelers.Num() > 0)
+		{
+			SafeLocation += (SafeLocation - ClosestPointOnLineToCapsuleCenter).GetSafeNormal() * PushInDistance;
+		}
+
+		// Then aim line to desired camera position
+		bool const bSingleRayPenetrationCheck = !bDoPredictiveAvoidance;
+		PreventCameraPenetration(*PPActor, SafeLocation, View.Location, DeltaTime, AimLineToDesiredPosBlockedPct, bSingleRayPenetrationCheck);
+
+		ILyraCameraAssistInterface* AssistArray[] = { TargetControllerAssist, TargetActorAssist, PPActorAssist };
+
+		if (AimLineToDesiredPosBlockedPct < ReportPenetrationPercent)
+		{
+			for (ILyraCameraAssistInterface* Assist : AssistArray)
+			{
+				if (Assist)
+				{
+					// camera is too close, tell the assists
+					Assist->OnCameraPenetratingTarget();
+				}
+			}
+		}
+	}
+}
+
+void ULyraCameraMode_ThirdPerson::PreventCameraPenetration(class AActor const& ViewTarget, FVector const& SafeLoc, FVector& CameraLoc, float const& DeltaTime, float& DistBlockedPct, bool bSingleRayOnly)
+{
+#if ENABLE_DRAW_DEBUG
+	DebugActorsHitDuringCameraPenetration.Reset();
+#endif
+
+	float HardBlockedPct = DistBlockedPct;
+	float SoftBlockedPct = DistBlockedPct;
+
+	FVector BaseRay = CameraLoc - SafeLoc;
+	FRotationMatrix BaseRayMatrix(BaseRay.Rotation());
+	FVector BaseRayLocalUp, BaseRayLocalFwd, BaseRayLocalRight;
+
+	BaseRayMatrix.GetScaledAxes(BaseRayLocalFwd, BaseRayLocalRight, BaseRayLocalUp);
+
+	float DistBlockedPctThisFrame = 1.f;
+
+	int32 const NumRaysToShoot = bSingleRayOnly ? FMath::Min(1, PenetrationAvoidanceFeelers.Num()) : PenetrationAvoidanceFeelers.Num();
+	FCollisionQueryParams SphereParams(SCENE_QUERY_STAT(CameraPen), false, nullptr/*PlayerCamera*/);
+
+	SphereParams.AddIgnoredActor(&ViewTarget);
+
+	//TODO ILyraCameraTarget.GetIgnoredActorsForCameraPentration();
+	//if (IgnoreActorForCameraPenetration)
+	//{
+	//	SphereParams.AddIgnoredActor(IgnoreActorForCameraPenetration);
+	//}
+
+	FCollisionShape SphereShape = FCollisionShape::MakeSphere(0.f);
+	UWorld* World = GetWorld();
+
+	for (int32 RayIdx = 0; RayIdx < NumRaysToShoot; ++RayIdx)
+	{
+		FLyraPenetrationAvoidanceFeeler& Feeler = PenetrationAvoidanceFeelers[RayIdx];
+		if (Feeler.FramesUntilNextTrace <= 0)
+		{
+			// calc ray target
+			FVector RayTarget;
+			{
+				FVector RotatedRay = BaseRay.RotateAngleAxis(Feeler.AdjustmentRot.Yaw, BaseRayLocalUp);
+				RotatedRay = RotatedRay.RotateAngleAxis(Feeler.AdjustmentRot.Pitch, BaseRayLocalRight);
+				RayTarget = SafeLoc + RotatedRay;
+			}
+
+			// cast for world and pawn hits separately.  this is so we can safely ignore the 
+			// camera's target pawn
+			SphereShape.Sphere.Radius = Feeler.Extent;
+			ECollisionChannel TraceChannel = ECC_Camera;		//(Feeler.PawnWeight > 0.f) ? ECC_Pawn : ECC_Camera;
+
+			// do multi-line check to make sure the hits we throw out aren't
+			// masking real hits behind (these are important rays).
+
+			// MT-> passing camera as actor so that camerablockingvolumes know when it's the camera doing traces
+			FHitResult Hit;
+			const bool bHit = World->SweepSingleByChannel(Hit, SafeLoc, RayTarget, FQuat::Identity, TraceChannel, SphereShape, SphereParams);
+#if ENABLE_DRAW_DEBUG
+			if (World->TimeSince(LastDrawDebugTime) < 1.f)
+			{
+				DrawDebugSphere(World, SafeLoc, SphereShape.Sphere.Radius, 8, FColor::Red);
+				DrawDebugSphere(World, bHit ? Hit.Location : RayTarget, SphereShape.Sphere.Radius, 8, FColor::Red);
+				DrawDebugLine(World, SafeLoc, bHit ? Hit.Location : RayTarget, FColor::Red);
+			}
+#endif // ENABLE_DRAW_DEBUG
+
+			Feeler.FramesUntilNextTrace = Feeler.TraceInterval;
+
+			const AActor* HitActor = Hit.GetActor();
+
+			if (bHit && HitActor)
+			{
+				bool bIgnoreHit = false;
+
+				if (HitActor->ActorHasTag(LyraCameraMode_ThirdPerson_Statics::NAME_IgnoreCameraCollision))
+				{
+					bIgnoreHit = true;
+					SphereParams.AddIgnoredActor(HitActor);
+				}
+
+				// Ignore CameraBlockingVolume hits that occur in front of the ViewTarget.
+				if (!bIgnoreHit && HitActor->IsA<ACameraBlockingVolume>())
+				{
+					const FVector ViewTargetForwardXY = ViewTarget.GetActorForwardVector().GetSafeNormal2D();
+					const FVector ViewTargetLocation = ViewTarget.GetActorLocation();
+					const FVector HitOffset = Hit.Location - ViewTargetLocation;
+					const FVector HitDirectionXY = HitOffset.GetSafeNormal2D();
+					const float DotHitDirection = FVector::DotProduct(ViewTargetForwardXY, HitDirectionXY);
+					if (DotHitDirection > 0.0f)
+					{
+						bIgnoreHit = true;
+						// Ignore this CameraBlockingVolume on the remaining sweeps.
+						SphereParams.AddIgnoredActor(HitActor);
+					}
+					else
+					{
+#if ENABLE_DRAW_DEBUG
+						DebugActorsHitDuringCameraPenetration.AddUnique(TObjectPtr<const AActor>(HitActor));
+#endif
+					}
+				}
+				
+				if (!bIgnoreHit)
+				{
+					float const Weight = Cast<APawn>(Hit.GetActor()) ? Feeler.PawnWeight : Feeler.WorldWeight;
+					float NewBlockPct = Hit.Time;
+					NewBlockPct += (1.f - NewBlockPct) * (1.f - Weight);
+
+					// Recompute blocked pct taking into account pushout distance.
+					NewBlockPct = ((Hit.Location - SafeLoc).Size() - CollisionPushOutDistance) / (RayTarget - SafeLoc).Size();
+					DistBlockedPctThisFrame = FMath::Min(NewBlockPct, DistBlockedPctThisFrame);
+
+					// This feeler got a hit, so do another trace next frame
+					Feeler.FramesUntilNextTrace = 0;
+
+#if ENABLE_DRAW_DEBUG
+					DebugActorsHitDuringCameraPenetration.AddUnique(TObjectPtr<const AActor>(HitActor));
+#endif
+				}
+			}
+
+			if (RayIdx == 0)
+			{
+				// don't interpolate toward this one, snap to it
+				// assumes ray 0 is the center/main ray 
+				HardBlockedPct = DistBlockedPctThisFrame;
+			}
+			else
+			{
+				SoftBlockedPct = DistBlockedPctThisFrame;
+			}
+		}
+		else
+		{
+			--Feeler.FramesUntilNextTrace;
+		}
+	}
+
+	if (bResetInterpolation)
+	{
+		DistBlockedPct = DistBlockedPctThisFrame;
+	}
+	else if (DistBlockedPct < DistBlockedPctThisFrame)
+	{
+		// interpolate smoothly out
+		if (PenetrationBlendOutTime > DeltaTime)
+		{
+			DistBlockedPct = DistBlockedPct + DeltaTime / PenetrationBlendOutTime * (DistBlockedPctThisFrame - DistBlockedPct);
+		}
+		else
+		{
+			DistBlockedPct = DistBlockedPctThisFrame;
+		}
+	}
+	else
+	{
+		if (DistBlockedPct > HardBlockedPct)
+		{
+			DistBlockedPct = HardBlockedPct;
+		}
+		else if (DistBlockedPct > SoftBlockedPct)
+		{
+			// interpolate smoothly in
+			if (PenetrationBlendInTime > DeltaTime)
+			{
+				DistBlockedPct = DistBlockedPct - DeltaTime / PenetrationBlendInTime * (DistBlockedPct - SoftBlockedPct);
+			}
+			else
+			{
+				DistBlockedPct = SoftBlockedPct;
+			}
+		}
+	}
+
+	DistBlockedPct = FMath::Clamp<float>(DistBlockedPct, 0.f, 1.f);
+	if (DistBlockedPct < (1.f - ZERO_ANIMWEIGHT_THRESH))
+	{
+		CameraLoc = SafeLoc + (CameraLoc - SafeLoc) * DistBlockedPct;
+	}
+}
+
+void ULyraCameraMode_ThirdPerson::SetTargetCrouchOffset(FVector NewTargetOffset)
+{
+	CrouchOffsetBlendPct = 0.0f;
+	InitialCrouchOffset = CurrentCrouchOffset;
+	TargetCrouchOffset = NewTargetOffset;
+}
+
+
+void ULyraCameraMode_ThirdPerson::UpdateCrouchOffset(float DeltaTime)
+{
+	if (CrouchOffsetBlendPct < 1.0f)
+	{
+		CrouchOffsetBlendPct = FMath::Min(CrouchOffsetBlendPct + DeltaTime * CrouchOffsetBlendMultiplier, 1.0f);
+		CurrentCrouchOffset = FMath::InterpEaseInOut(InitialCrouchOffset, TargetCrouchOffset, CrouchOffsetBlendPct, 1.0f);
+	}
+	else
+	{
+		CurrentCrouchOffset = TargetCrouchOffset;
+		CrouchOffsetBlendPct = 1.0f;
+	}
+}
+

LyraStarterGame/Source/LyraGame/Camera/LyraCameraMode_ThirdPerson.h

@@ -0,0 +1,114 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "LyraCameraMode.h"
+#include "Curves/CurveFloat.h"
+#include "LyraPenetrationAvoidanceFeeler.h"
+#include "DrawDebugHelpers.h"
+#include "LyraCameraMode_ThirdPerson.generated.h"
+
+class UCurveVector;
+
+/**
+ * ULyraCameraMode_ThirdPerson
+ *
+ *	A basic third person camera mode.
+ */
+UCLASS(Abstract, Blueprintable)
+class ULyraCameraMode_ThirdPerson : public ULyraCameraMode
+{
+	GENERATED_BODY()
+
+public:
+
+	ULyraCameraMode_ThirdPerson();
+
+protected:
+
+	virtual void UpdateView(float DeltaTime) override;
+
+	void UpdateForTarget(float DeltaTime);
+	void UpdatePreventPenetration(float DeltaTime);
+	void PreventCameraPenetration(class AActor const& ViewTarget, FVector const& SafeLoc, FVector& CameraLoc, float const& DeltaTime, float& DistBlockedPct, bool bSingleRayOnly);
+
+	virtual void DrawDebug(UCanvas* Canvas) const override;
+
+protected:
+
+	// Curve that defines local-space offsets from the target using the view pitch to evaluate the curve.
+	UPROPERTY(EditDefaultsOnly, Category = "Third Person", Meta = (EditCondition = "!bUseRuntimeFloatCurves"))
+	TObjectPtr<const UCurveVector> TargetOffsetCurve;
+
+	// UE-103986: Live editing of RuntimeFloatCurves during PIE does not work (unlike curve assets).
+	// Once that is resolved this will become the default and TargetOffsetCurve will be removed.
+	UPROPERTY(EditDefaultsOnly, Category = "Third Person")
+	bool bUseRuntimeFloatCurves;
+
+	UPROPERTY(EditDefaultsOnly, Category = "Third Person", Meta = (EditCondition = "bUseRuntimeFloatCurves"))
+	FRuntimeFloatCurve TargetOffsetX;
+
+	UPROPERTY(EditDefaultsOnly, Category = "Third Person", Meta = (EditCondition = "bUseRuntimeFloatCurves"))
+	FRuntimeFloatCurve TargetOffsetY;
+
+	UPROPERTY(EditDefaultsOnly, Category = "Third Person", Meta = (EditCondition = "bUseRuntimeFloatCurves"))
+	FRuntimeFloatCurve TargetOffsetZ;
+
+	// Alters the speed that a crouch offset is blended in or out
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Third Person")
+	float CrouchOffsetBlendMultiplier = 5.0f;
+
+	// Penetration prevention
+public:
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Collision")
+	float PenetrationBlendInTime = 0.1f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Collision")
+	float PenetrationBlendOutTime = 0.15f;
+
+	/** If true, does collision checks to keep the camera out of the world. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Collision")
+	bool bPreventPenetration = true;
+
+	/** If true, try to detect nearby walls and move the camera in anticipation.  Helps prevent popping. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Collision")
+	bool bDoPredictiveAvoidance = true;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Collision")
+	float CollisionPushOutDistance = 2.f;
+
+	/** When the camera's distance is pushed into this percentage of its full distance due to penetration */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Collision")
+	float ReportPenetrationPercent = 0.f;
+
+	/**
+	 * These are the feeler rays that are used to find where to place the camera.
+	 * Index: 0  : This is the normal feeler we use to prevent collisions.
+	 * Index: 1+ : These feelers are used if you bDoPredictiveAvoidance=true, to scan for potential impacts if the player
+	 *             were to rotate towards that direction and primitively collide the camera so that it pulls in before
+	 *             impacting the occluder.
+	 */
+	UPROPERTY(EditDefaultsOnly, Category = "Collision")
+	TArray<FLyraPenetrationAvoidanceFeeler> PenetrationAvoidanceFeelers;
+
+	UPROPERTY(Transient)
+	float AimLineToDesiredPosBlockedPct;
+
+	UPROPERTY(Transient)
+	TArray<TObjectPtr<const AActor>> DebugActorsHitDuringCameraPenetration;
+
+#if ENABLE_DRAW_DEBUG
+	mutable float LastDrawDebugTime = -MAX_FLT;
+#endif
+
+protected:
+	
+	void SetTargetCrouchOffset(FVector NewTargetOffset);
+	void UpdateCrouchOffset(float DeltaTime);
+
+	FVector InitialCrouchOffset = FVector::ZeroVector;
+	FVector TargetCrouchOffset = FVector::ZeroVector;
+	float CrouchOffsetBlendPct = 1.0f;
+	FVector CurrentCrouchOffset = FVector::ZeroVector;
+	
+};

LyraStarterGame/Source/LyraGame/Camera/LyraPenetrationAvoidanceFeeler.h

@@ -0,0 +1,66 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+
+#include "LyraPenetrationAvoidanceFeeler.generated.h"
+
+/**
+ * Struct defining a feeler ray used for camera penetration avoidance.
+ */
+USTRUCT()
+struct FLyraPenetrationAvoidanceFeeler
+{
+	GENERATED_BODY()
+
+	/** FRotator describing deviance from main ray */
+	UPROPERTY(EditAnywhere, Category=PenetrationAvoidanceFeeler)
+	FRotator AdjustmentRot;
+
+	/** how much this feeler affects the final position if it hits the world */
+	UPROPERTY(EditAnywhere, Category=PenetrationAvoidanceFeeler)
+	float WorldWeight;
+
+	/** how much this feeler affects the final position if it hits a APawn (setting to 0 will not attempt to collide with pawns at all) */
+	UPROPERTY(EditAnywhere, Category=PenetrationAvoidanceFeeler)
+	float PawnWeight;
+
+	/** extent to use for collision when tracing this feeler */
+	UPROPERTY(EditAnywhere, Category=PenetrationAvoidanceFeeler)
+	float Extent;
+
+	/** minimum frame interval between traces with this feeler if nothing was hit last frame */
+	UPROPERTY(EditAnywhere, Category=PenetrationAvoidanceFeeler)
+	int32 TraceInterval;
+
+	/** number of frames since this feeler was used */
+	UPROPERTY(transient)
+	int32 FramesUntilNextTrace;
+
+
+	FLyraPenetrationAvoidanceFeeler()
+		: AdjustmentRot(ForceInit)
+		, WorldWeight(0)
+		, PawnWeight(0)
+		, Extent(0)
+		, TraceInterval(0)
+		, FramesUntilNextTrace(0)
+	{
+	}
+
+	FLyraPenetrationAvoidanceFeeler(const FRotator& InAdjustmentRot,
+									const float& InWorldWeight, 
+									const float& InPawnWeight, 
+									const float& InExtent, 
+									const int32& InTraceInterval = 0, 
+									const int32& InFramesUntilNextTrace = 0)
+		: AdjustmentRot(InAdjustmentRot)
+		, WorldWeight(InWorldWeight)
+		, PawnWeight(InPawnWeight)
+		, Extent(InExtent)
+		, TraceInterval(InTraceInterval)
+		, FramesUntilNextTrace(InFramesUntilNextTrace)
+	{
+	}
+};

LyraStarterGame/Source/LyraGame/Camera/LyraPlayerCameraManager.cpp

@@ -0,0 +1,66 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraPlayerCameraManager.h"
+
+#include "Async/TaskGraphInterfaces.h"
+#include "Engine/Canvas.h"
+#include "Engine/Engine.h"
+#include "GameFramework/Pawn.h"
+#include "GameFramework/PlayerController.h"
+#include "LyraCameraComponent.h"
+#include "LyraUICameraManagerComponent.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraPlayerCameraManager)
+
+class FDebugDisplayInfo;
+
+static FName UICameraComponentName(TEXT("UICamera"));
+
+ALyraPlayerCameraManager::ALyraPlayerCameraManager(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+	DefaultFOV = LYRA_CAMERA_DEFAULT_FOV;
+	ViewPitchMin = LYRA_CAMERA_DEFAULT_PITCH_MIN;
+	ViewPitchMax = LYRA_CAMERA_DEFAULT_PITCH_MAX;
+
+	UICamera = CreateDefaultSubobject<ULyraUICameraManagerComponent>(UICameraComponentName);
+}
+
+ULyraUICameraManagerComponent* ALyraPlayerCameraManager::GetUICameraComponent() const
+{
+	return UICamera;
+}
+
+void ALyraPlayerCameraManager::UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime)
+{
+	// If the UI Camera is looking at something, let it have priority.
+	if (UICamera->NeedsToUpdateViewTarget())
+	{
+		Super::UpdateViewTarget(OutVT, DeltaTime);
+		UICamera->UpdateViewTarget(OutVT, DeltaTime);
+		return;
+	}
+
+	Super::UpdateViewTarget(OutVT, DeltaTime);
+}
+
+void ALyraPlayerCameraManager::DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos)
+{
+	check(Canvas);
+
+	FDisplayDebugManager& DisplayDebugManager = Canvas->DisplayDebugManager;
+
+	DisplayDebugManager.SetFont(GEngine->GetSmallFont());
+	DisplayDebugManager.SetDrawColor(FColor::Yellow);
+	DisplayDebugManager.DrawString(FString::Printf(TEXT("LyraPlayerCameraManager: %s"), *GetNameSafe(this)));
+
+	Super::DisplayDebug(Canvas, DebugDisplay, YL, YPos);
+
+	const APawn* Pawn = (PCOwner ? PCOwner->GetPawn() : nullptr);
+
+	if (const ULyraCameraComponent* CameraComponent = ULyraCameraComponent::FindCameraComponent(Pawn))
+	{
+		CameraComponent->DrawDebug(Canvas);
+	}
+}
+

LyraStarterGame/Source/LyraGame/Camera/LyraPlayerCameraManager.h

@@ -0,0 +1,46 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Camera/PlayerCameraManager.h"
+
+#include "LyraPlayerCameraManager.generated.h"
+
+class FDebugDisplayInfo;
+class UCanvas;
+class UObject;
+
+
+#define LYRA_CAMERA_DEFAULT_FOV			(80.0f)
+#define LYRA_CAMERA_DEFAULT_PITCH_MIN	(-89.0f)
+#define LYRA_CAMERA_DEFAULT_PITCH_MAX	(89.0f)
+
+class ULyraUICameraManagerComponent;
+
+/**
+ * ALyraPlayerCameraManager
+ *
+ *	The base player camera manager class used by this project.
+ */
+UCLASS(notplaceable, MinimalAPI)
+class ALyraPlayerCameraManager : public APlayerCameraManager
+{
+	GENERATED_BODY()
+
+public:
+
+	ALyraPlayerCameraManager(const FObjectInitializer& ObjectInitializer);
+
+	ULyraUICameraManagerComponent* GetUICameraComponent() const;
+
+protected:
+
+	virtual void UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime) override;
+
+	virtual void DisplayDebug(UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
+
+private:
+	/** The UI Camera Component, controls the camera when UI is doing something important that gameplay doesn't get priority over. */
+	UPROPERTY(Transient)
+	TObjectPtr<ULyraUICameraManagerComponent> UICamera;
+};

LyraStarterGame/Source/LyraGame/Camera/LyraUICameraManagerComponent.cpp

@@ -0,0 +1,65 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraUICameraManagerComponent.h"
+
+#include "GameFramework/HUD.h"
+#include "GameFramework/PlayerController.h"
+#include "LyraPlayerCameraManager.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraUICameraManagerComponent)
+
+class AActor;
+class FDebugDisplayInfo;
+
+ULyraUICameraManagerComponent* ULyraUICameraManagerComponent::GetComponent(APlayerController* PC)
+{
+	if (PC != nullptr)
+	{
+		if (ALyraPlayerCameraManager* PCCamera = Cast<ALyraPlayerCameraManager>(PC->PlayerCameraManager))
+		{
+			return PCCamera->GetUICameraComponent();
+		}
+	}
+
+	return nullptr;
+}
+
+ULyraUICameraManagerComponent::ULyraUICameraManagerComponent()
+{
+	bWantsInitializeComponent = true;
+
+	if (!HasAnyFlags(RF_ClassDefaultObject))
+	{
+		// Register "showdebug" hook.
+		if (!IsRunningDedicatedServer())
+		{
+			AHUD::OnShowDebugInfo.AddUObject(this, &ThisClass::OnShowDebugInfo);
+		}
+	}
+}
+
+void ULyraUICameraManagerComponent::InitializeComponent()
+{
+	Super::InitializeComponent();
+}
+
+void ULyraUICameraManagerComponent::SetViewTarget(AActor* InViewTarget, FViewTargetTransitionParams TransitionParams)
+{
+	TGuardValue<bool> UpdatingViewTargetGuard(bUpdatingViewTarget, true);
+
+	ViewTarget = InViewTarget;
+	CastChecked<ALyraPlayerCameraManager>(GetOwner())->SetViewTarget(ViewTarget, TransitionParams);
+}
+
+bool ULyraUICameraManagerComponent::NeedsToUpdateViewTarget() const
+{
+	return false;
+}
+
+void ULyraUICameraManagerComponent::UpdateViewTarget(struct FTViewTarget& OutVT, float DeltaTime)
+{
+}
+
+void ULyraUICameraManagerComponent::OnShowDebugInfo(AHUD* HUD, UCanvas* Canvas, const FDebugDisplayInfo& DisplayInfo, float& YL, float& YPos)
+{
+}

LyraStarterGame/Source/LyraGame/Camera/LyraUICameraManagerComponent.h

@@ -0,0 +1,45 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Camera/PlayerCameraManager.h"
+
+#include "LyraUICameraManagerComponent.generated.h"
+
+class ALyraPlayerCameraManager;
+
+class AActor;
+class AHUD;
+class APlayerController;
+class FDebugDisplayInfo;
+class UCanvas;
+class UObject;
+
+UCLASS( Transient, Within=LyraPlayerCameraManager )
+class ULyraUICameraManagerComponent : public UActorComponent
+{
+	GENERATED_BODY()
+
+public:
+	static ULyraUICameraManagerComponent* GetComponent(APlayerController* PC);
+
+public:
+	ULyraUICameraManagerComponent();	
+	virtual void InitializeComponent() override;
+
+	bool IsSettingViewTarget() const { return bUpdatingViewTarget; }
+	AActor* GetViewTarget() const { return ViewTarget; }
+	void SetViewTarget(AActor* InViewTarget, FViewTargetTransitionParams TransitionParams = FViewTargetTransitionParams());
+
+	bool NeedsToUpdateViewTarget() const;
+	void UpdateViewTarget(struct FTViewTarget& OutVT, float DeltaTime);
+
+	void OnShowDebugInfo(AHUD* HUD, UCanvas* Canvas, const FDebugDisplayInfo& DisplayInfo, float& YL, float& YPos);
+
+private:
+	UPROPERTY(Transient)
+	TObjectPtr<AActor> ViewTarget;
+	
+	UPROPERTY(Transient)
+	bool bUpdatingViewTarget;
+};

LyraStarterGame/Source/LyraGame/Character/LyraCharacter.cpp

@@ -0,0 +1,682 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraCharacter.h"
+
+#include "AbilitySystem/LyraAbilitySystemComponent.h"
+#include "Camera/LyraCameraComponent.h"
+#include "Character/LyraHealthComponent.h"
+#include "Character/LyraPawnExtensionComponent.h"
+#include "Components/CapsuleComponent.h"
+#include "Components/SkeletalMeshComponent.h"
+#include "LyraCharacterMovementComponent.h"
+#include "LyraGameplayTags.h"
+#include "LyraLogChannels.h"
+#include "Net/UnrealNetwork.h"
+#include "Player/LyraPlayerController.h"
+#include "Player/LyraPlayerState.h"
+#include "System/LyraSignificanceManager.h"
+#include "TimerManager.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraCharacter)
+
+class AActor;
+class FLifetimeProperty;
+class IRepChangedPropertyTracker;
+class UInputComponent;
+
+static FName NAME_LyraCharacterCollisionProfile_Capsule(TEXT("LyraPawnCapsule"));
+static FName NAME_LyraCharacterCollisionProfile_Mesh(TEXT("LyraPawnMesh"));
+
+ALyraCharacter::ALyraCharacter(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer.SetDefaultSubobjectClass<ULyraCharacterMovementComponent>(ACharacter::CharacterMovementComponentName))
+{
+	// Avoid ticking characters if possible.
+	PrimaryActorTick.bCanEverTick = false;
+	PrimaryActorTick.bStartWithTickEnabled = false;
+
+	SetNetCullDistanceSquared(900000000.0f);
+
+	UCapsuleComponent* CapsuleComp = GetCapsuleComponent();
+	check(CapsuleComp);
+	CapsuleComp->InitCapsuleSize(40.0f, 90.0f);
+	CapsuleComp->SetCollisionProfileName(NAME_LyraCharacterCollisionProfile_Capsule);
+
+	USkeletalMeshComponent* MeshComp = GetMesh();
+	check(MeshComp);
+	MeshComp->SetRelativeRotation(FRotator(0.0f, -90.0f, 0.0f));  // Rotate mesh to be X forward since it is exported as Y forward.
+	MeshComp->SetCollisionProfileName(NAME_LyraCharacterCollisionProfile_Mesh);
+
+	ULyraCharacterMovementComponent* LyraMoveComp = CastChecked<ULyraCharacterMovementComponent>(GetCharacterMovement());
+	LyraMoveComp->GravityScale = 1.0f;
+	LyraMoveComp->MaxAcceleration = 2400.0f;
+	LyraMoveComp->BrakingFrictionFactor = 1.0f;
+	LyraMoveComp->BrakingFriction = 6.0f;
+	LyraMoveComp->GroundFriction = 8.0f;
+	LyraMoveComp->BrakingDecelerationWalking = 1400.0f;
+	LyraMoveComp->bUseControllerDesiredRotation = false;
+	LyraMoveComp->bOrientRotationToMovement = false;
+	LyraMoveComp->RotationRate = FRotator(0.0f, 720.0f, 0.0f);
+	LyraMoveComp->bAllowPhysicsRotationDuringAnimRootMotion = false;
+	LyraMoveComp->GetNavAgentPropertiesRef().bCanCrouch = true;
+	LyraMoveComp->bCanWalkOffLedgesWhenCrouching = true;
+	LyraMoveComp->SetCrouchedHalfHeight(65.0f);
+
+	PawnExtComponent = CreateDefaultSubobject<ULyraPawnExtensionComponent>(TEXT("PawnExtensionComponent"));
+	PawnExtComponent->OnAbilitySystemInitialized_RegisterAndCall(FSimpleMulticastDelegate::FDelegate::CreateUObject(this, &ThisClass::OnAbilitySystemInitialized));
+	PawnExtComponent->OnAbilitySystemUninitialized_Register(FSimpleMulticastDelegate::FDelegate::CreateUObject(this, &ThisClass::OnAbilitySystemUninitialized));
+
+	HealthComponent = CreateDefaultSubobject<ULyraHealthComponent>(TEXT("HealthComponent"));
+	HealthComponent->OnDeathStarted.AddDynamic(this, &ThisClass::OnDeathStarted);
+	HealthComponent->OnDeathFinished.AddDynamic(this, &ThisClass::OnDeathFinished);
+
+	CameraComponent = CreateDefaultSubobject<ULyraCameraComponent>(TEXT("CameraComponent"));
+	CameraComponent->SetRelativeLocation(FVector(-300.0f, 0.0f, 75.0f));
+
+	bUseControllerRotationPitch = false;
+	bUseControllerRotationYaw = true;
+	bUseControllerRotationRoll = false;
+
+	BaseEyeHeight = 80.0f;
+	CrouchedEyeHeight = 50.0f;
+}
+
+void ALyraCharacter::PreInitializeComponents()
+{
+	Super::PreInitializeComponents();
+}
+
+void ALyraCharacter::BeginPlay()
+{
+	Super::BeginPlay();
+
+	UWorld* World = GetWorld();
+
+	const bool bRegisterWithSignificanceManager = !IsNetMode(NM_DedicatedServer);
+	if (bRegisterWithSignificanceManager)
+	{
+		if (ULyraSignificanceManager* SignificanceManager = USignificanceManager::Get<ULyraSignificanceManager>(World))
+		{
+//@TODO: SignificanceManager->RegisterObject(this, (EFortSignificanceType)SignificanceType);
+		}
+	}
+}
+
+void ALyraCharacter::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	Super::EndPlay(EndPlayReason);
+
+	UWorld* World = GetWorld();
+
+	const bool bRegisterWithSignificanceManager = !IsNetMode(NM_DedicatedServer);
+	if (bRegisterWithSignificanceManager)
+	{
+		if (ULyraSignificanceManager* SignificanceManager = USignificanceManager::Get<ULyraSignificanceManager>(World))
+		{
+			SignificanceManager->UnregisterObject(this);
+		}
+	}
+}
+
+void ALyraCharacter::Reset()
+{
+	DisableMovementAndCollision();
+
+	K2_OnReset();
+
+	UninitAndDestroy();
+}
+
+void ALyraCharacter::GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const
+{
+	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+
+	DOREPLIFETIME_CONDITION(ThisClass, ReplicatedAcceleration, COND_SimulatedOnly);
+	DOREPLIFETIME(ThisClass, MyTeamID)
+}
+
+void ALyraCharacter::PreReplication(IRepChangedPropertyTracker& ChangedPropertyTracker)
+{
+	Super::PreReplication(ChangedPropertyTracker);
+
+	if (UCharacterMovementComponent* MovementComponent = GetCharacterMovement())
+	{
+		// Compress Acceleration: XY components as direction + magnitude, Z component as direct value
+		const double MaxAccel = MovementComponent->MaxAcceleration;
+		const FVector CurrentAccel = MovementComponent->GetCurrentAcceleration();
+		double AccelXYRadians, AccelXYMagnitude;
+		FMath::CartesianToPolar(CurrentAccel.X, CurrentAccel.Y, AccelXYMagnitude, AccelXYRadians);
+
+		ReplicatedAcceleration.AccelXYRadians   = FMath::FloorToInt((AccelXYRadians / TWO_PI) * 255.0);     // [0, 2PI] -> [0, 255]
+		ReplicatedAcceleration.AccelXYMagnitude = FMath::FloorToInt((AccelXYMagnitude / MaxAccel) * 255.0);	// [0, MaxAccel] -> [0, 255]
+		ReplicatedAcceleration.AccelZ           = FMath::FloorToInt((CurrentAccel.Z / MaxAccel) * 127.0);   // [-MaxAccel, MaxAccel] -> [-127, 127]
+	}
+}
+
+void ALyraCharacter::NotifyControllerChanged()
+{
+	const FGenericTeamId OldTeamId = GetGenericTeamId();
+
+	Super::NotifyControllerChanged();
+
+	// Update our team ID based on the controller
+	if (HasAuthority() && (GetController() != nullptr))
+	{
+		if (ILyraTeamAgentInterface* ControllerWithTeam = Cast<ILyraTeamAgentInterface>(GetController()))
+		{
+			MyTeamID = ControllerWithTeam->GetGenericTeamId();
+			ConditionalBroadcastTeamChanged(this, OldTeamId, MyTeamID);
+		}
+	}
+}
+
+ALyraPlayerController* ALyraCharacter::GetLyraPlayerController() const
+{
+	return CastChecked<ALyraPlayerController>(GetController(), ECastCheckedType::NullAllowed);
+}
+
+ALyraPlayerState* ALyraCharacter::GetLyraPlayerState() const
+{
+	return CastChecked<ALyraPlayerState>(GetPlayerState(), ECastCheckedType::NullAllowed);
+}
+
+ULyraAbilitySystemComponent* ALyraCharacter::GetLyraAbilitySystemComponent() const
+{
+	return Cast<ULyraAbilitySystemComponent>(GetAbilitySystemComponent());
+}
+
+UAbilitySystemComponent* ALyraCharacter::GetAbilitySystemComponent() const
+{
+	if (PawnExtComponent == nullptr)
+	{
+		return nullptr;
+	}
+
+	return PawnExtComponent->GetLyraAbilitySystemComponent();
+}
+
+void ALyraCharacter::OnAbilitySystemInitialized()
+{
+	ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent();
+	check(LyraASC);
+
+	HealthComponent->InitializeWithAbilitySystem(LyraASC);
+
+	InitializeGameplayTags();
+}
+
+void ALyraCharacter::OnAbilitySystemUninitialized()
+{
+	HealthComponent->UninitializeFromAbilitySystem();
+}
+
+void ALyraCharacter::PossessedBy(AController* NewController)
+{
+	const FGenericTeamId OldTeamID = MyTeamID;
+
+	Super::PossessedBy(NewController);
+
+	PawnExtComponent->HandleControllerChanged();
+
+	// Grab the current team ID and listen for future changes
+	if (ILyraTeamAgentInterface* ControllerAsTeamProvider = Cast<ILyraTeamAgentInterface>(NewController))
+	{
+		MyTeamID = ControllerAsTeamProvider->GetGenericTeamId();
+		ControllerAsTeamProvider->GetTeamChangedDelegateChecked().AddDynamic(this, &ThisClass::OnControllerChangedTeam);
+	}
+	ConditionalBroadcastTeamChanged(this, OldTeamID, MyTeamID);
+}
+
+void ALyraCharacter::UnPossessed()
+{
+	AController* const OldController = GetController();
+
+	// Stop listening for changes from the old controller
+	const FGenericTeamId OldTeamID = MyTeamID;
+	if (ILyraTeamAgentInterface* ControllerAsTeamProvider = Cast<ILyraTeamAgentInterface>(OldController))
+	{
+		ControllerAsTeamProvider->GetTeamChangedDelegateChecked().RemoveAll(this);
+	}
+
+	Super::UnPossessed();
+
+	PawnExtComponent->HandleControllerChanged();
+
+	// Determine what the new team ID should be afterwards
+	MyTeamID = DetermineNewTeamAfterPossessionEnds(OldTeamID);
+	ConditionalBroadcastTeamChanged(this, OldTeamID, MyTeamID);
+}
+
+void ALyraCharacter::OnRep_Controller()
+{
+	Super::OnRep_Controller();
+
+	PawnExtComponent->HandleControllerChanged();
+}
+
+void ALyraCharacter::OnRep_PlayerState()
+{
+	Super::OnRep_PlayerState();
+
+	PawnExtComponent->HandlePlayerStateReplicated();
+}
+
+void ALyraCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
+{
+	Super::SetupPlayerInputComponent(PlayerInputComponent);
+
+	PawnExtComponent->SetupPlayerInputComponent();
+}
+
+void ALyraCharacter::InitializeGameplayTags()
+{
+	// Clear tags that may be lingering on the ability system from the previous pawn.
+	if (ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		for (const TPair<uint8, FGameplayTag>& TagMapping : LyraGameplayTags::MovementModeTagMap)
+		{
+			if (TagMapping.Value.IsValid())
+			{
+				LyraASC->SetLooseGameplayTagCount(TagMapping.Value, 0);
+			}
+		}
+
+		for (const TPair<uint8, FGameplayTag>& TagMapping : LyraGameplayTags::CustomMovementModeTagMap)
+		{
+			if (TagMapping.Value.IsValid())
+			{
+				LyraASC->SetLooseGameplayTagCount(TagMapping.Value, 0);
+			}
+		}
+
+		ULyraCharacterMovementComponent* LyraMoveComp = CastChecked<ULyraCharacterMovementComponent>(GetCharacterMovement());
+		SetMovementModeTag(LyraMoveComp->MovementMode, LyraMoveComp->CustomMovementMode, true);
+	}
+}
+
+void ALyraCharacter::GetOwnedGameplayTags(FGameplayTagContainer& TagContainer) const
+{
+	if (const ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		LyraASC->GetOwnedGameplayTags(TagContainer);
+	}
+}
+
+bool ALyraCharacter::HasMatchingGameplayTag(FGameplayTag TagToCheck) const
+{
+	if (const ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		return LyraASC->HasMatchingGameplayTag(TagToCheck);
+	}
+
+	return false;
+}
+
+bool ALyraCharacter::HasAllMatchingGameplayTags(const FGameplayTagContainer& TagContainer) const
+{
+	if (const ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		return LyraASC->HasAllMatchingGameplayTags(TagContainer);
+	}
+
+	return false;
+}
+
+bool ALyraCharacter::HasAnyMatchingGameplayTags(const FGameplayTagContainer& TagContainer) const
+{
+	if (const ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		return LyraASC->HasAnyMatchingGameplayTags(TagContainer);
+	}
+
+	return false;
+}
+
+void ALyraCharacter::FellOutOfWorld(const class UDamageType& dmgType)
+{
+	HealthComponent->DamageSelfDestruct(/*bFellOutOfWorld=*/ true);
+}
+
+void ALyraCharacter::OnDeathStarted(AActor*)
+{
+	DisableMovementAndCollision();
+}
+
+void ALyraCharacter::OnDeathFinished(AActor*)
+{
+	GetWorld()->GetTimerManager().SetTimerForNextTick(this, &ThisClass::DestroyDueToDeath);
+}
+
+
+void ALyraCharacter::DisableMovementAndCollision()
+{
+	if (GetController())
+	{
+		GetController()->SetIgnoreMoveInput(true);
+	}
+
+	UCapsuleComponent* CapsuleComp = GetCapsuleComponent();
+	check(CapsuleComp);
+	CapsuleComp->SetCollisionEnabled(ECollisionEnabled::NoCollision);
+	CapsuleComp->SetCollisionResponseToAllChannels(ECR_Ignore);
+
+	ULyraCharacterMovementComponent* LyraMoveComp = CastChecked<ULyraCharacterMovementComponent>(GetCharacterMovement());
+	LyraMoveComp->StopMovementImmediately();
+	LyraMoveComp->DisableMovement();
+}
+
+void ALyraCharacter::DestroyDueToDeath()
+{
+	K2_OnDeathFinished();
+
+	UninitAndDestroy();
+}
+
+
+void ALyraCharacter::UninitAndDestroy()
+{
+	if (GetLocalRole() == ROLE_Authority)
+	{
+		DetachFromControllerPendingDestroy();
+		SetLifeSpan(0.1f);
+	}
+
+	// Uninitialize the ASC if we're still the avatar actor (otherwise another pawn already did it when they became the avatar actor)
+	if (ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		if (LyraASC->GetAvatarActor() == this)
+		{
+			PawnExtComponent->UninitializeAbilitySystem();
+		}
+	}
+
+	SetActorHiddenInGame(true);
+}
+
+void ALyraCharacter::OnMovementModeChanged(EMovementMode PrevMovementMode, uint8 PreviousCustomMode)
+{
+	Super::OnMovementModeChanged(PrevMovementMode, PreviousCustomMode);
+
+	ULyraCharacterMovementComponent* LyraMoveComp = CastChecked<ULyraCharacterMovementComponent>(GetCharacterMovement());
+
+	SetMovementModeTag(PrevMovementMode, PreviousCustomMode, false);
+	SetMovementModeTag(LyraMoveComp->MovementMode, LyraMoveComp->CustomMovementMode, true);
+}
+
+void ALyraCharacter::SetMovementModeTag(EMovementMode MovementMode, uint8 CustomMovementMode, bool bTagEnabled)
+{
+	if (ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		const FGameplayTag* MovementModeTag = nullptr;
+		if (MovementMode == MOVE_Custom)
+		{
+			MovementModeTag = LyraGameplayTags::CustomMovementModeTagMap.Find(CustomMovementMode);
+		}
+		else
+		{
+			MovementModeTag = LyraGameplayTags::MovementModeTagMap.Find(MovementMode);
+		}
+
+		if (MovementModeTag && MovementModeTag->IsValid())
+		{
+			LyraASC->SetLooseGameplayTagCount(*MovementModeTag, (bTagEnabled ? 1 : 0));
+		}
+	}
+}
+
+void ALyraCharacter::ToggleCrouch()
+{
+	const ULyraCharacterMovementComponent* LyraMoveComp = CastChecked<ULyraCharacterMovementComponent>(GetCharacterMovement());
+
+	if (IsCrouched() || LyraMoveComp->bWantsToCrouch)
+	{
+		UnCrouch();
+	}
+	else if (LyraMoveComp->IsMovingOnGround())
+	{
+		Crouch();
+	}
+}
+
+void ALyraCharacter::OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust)
+{
+	if (ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		LyraASC->SetLooseGameplayTagCount(LyraGameplayTags::Status_Crouching, 1);
+	}
+
+
+	Super::OnStartCrouch(HalfHeightAdjust, ScaledHalfHeightAdjust);
+}
+
+void ALyraCharacter::OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust)
+{
+	if (ULyraAbilitySystemComponent* LyraASC = GetLyraAbilitySystemComponent())
+	{
+		LyraASC->SetLooseGameplayTagCount(LyraGameplayTags::Status_Crouching, 0);
+	}
+
+	Super::OnEndCrouch(HalfHeightAdjust, ScaledHalfHeightAdjust);
+}
+
+bool ALyraCharacter::CanJumpInternal_Implementation() const
+{
+	// same as ACharacter's implementation but without the crouch check
+	return JumpIsAllowedInternal();
+}
+
+void ALyraCharacter::OnRep_ReplicatedAcceleration()
+{
+	if (ULyraCharacterMovementComponent* LyraMovementComponent = Cast<ULyraCharacterMovementComponent>(GetCharacterMovement()))
+	{
+		// Decompress Acceleration
+		const double MaxAccel         = LyraMovementComponent->MaxAcceleration;
+		const double AccelXYMagnitude = double(ReplicatedAcceleration.AccelXYMagnitude) * MaxAccel / 255.0; // [0, 255] -> [0, MaxAccel]
+		const double AccelXYRadians   = double(ReplicatedAcceleration.AccelXYRadians) * TWO_PI / 255.0;     // [0, 255] -> [0, 2PI]
+
+		FVector UnpackedAcceleration(FVector::ZeroVector);
+		FMath::PolarToCartesian(AccelXYMagnitude, AccelXYRadians, UnpackedAcceleration.X, UnpackedAcceleration.Y);
+		UnpackedAcceleration.Z = double(ReplicatedAcceleration.AccelZ) * MaxAccel / 127.0; // [-127, 127] -> [-MaxAccel, MaxAccel]
+
+		LyraMovementComponent->SetReplicatedAcceleration(UnpackedAcceleration);
+	}
+}
+
+void ALyraCharacter::SetGenericTeamId(const FGenericTeamId& NewTeamID)
+{
+	if (GetController() == nullptr)
+	{
+		if (HasAuthority())
+		{
+			const FGenericTeamId OldTeamID = MyTeamID;
+			MyTeamID = NewTeamID;
+			ConditionalBroadcastTeamChanged(this, OldTeamID, MyTeamID);
+		}
+		else
+		{
+			UE_LOG(LogLyraTeams, Error, TEXT("You can't set the team ID on a character (%s) except on the authority"), *GetPathNameSafe(this));
+		}
+	}
+	else
+	{
+		UE_LOG(LogLyraTeams, Error, TEXT("You can't set the team ID on a possessed character (%s); it's driven by the associated controller"), *GetPathNameSafe(this));
+	}
+}
+
+FGenericTeamId ALyraCharacter::GetGenericTeamId() const
+{
+	return MyTeamID;
+}
+
+FOnLyraTeamIndexChangedDelegate* ALyraCharacter::GetOnTeamIndexChangedDelegate()
+{
+	return &OnTeamChangedDelegate;
+}
+
+void ALyraCharacter::OnControllerChangedTeam(UObject* TeamAgent, int32 OldTeam, int32 NewTeam)
+{
+	const FGenericTeamId MyOldTeamID = MyTeamID;
+	MyTeamID = IntegerToGenericTeamId(NewTeam);
+	ConditionalBroadcastTeamChanged(this, MyOldTeamID, MyTeamID);
+}
+
+void ALyraCharacter::OnRep_MyTeamID(FGenericTeamId OldTeamID)
+{
+	ConditionalBroadcastTeamChanged(this, OldTeamID, MyTeamID);
+}
+
+bool ALyraCharacter::UpdateSharedReplication()
+{
+	if (GetLocalRole() == ROLE_Authority)
+	{
+		FSharedRepMovement SharedMovement;
+		if (SharedMovement.FillForCharacter(this))
+		{
+			// Only call FastSharedReplication if data has changed since the last frame.
+			// Skipping this call will cause replication to reuse the same bunch that we previously
+			// produced, but not send it to clients that already received. (But a new client who has not received
+			// it, will get it this frame)
+			if (!SharedMovement.Equals(LastSharedReplication, this))
+			{
+				LastSharedReplication = SharedMovement;
+				SetReplicatedMovementMode(SharedMovement.RepMovementMode);
+
+				FastSharedReplication(SharedMovement);
+			}
+			return true;
+		}
+	}
+
+	// We cannot fastrep right now. Don't send anything.
+	return false;
+}
+
+void ALyraCharacter::FastSharedReplication_Implementation(const FSharedRepMovement& SharedRepMovement)
+{
+	if (GetWorld()->IsPlayingReplay())
+	{
+		return;
+	}
+
+	// Timestamp is checked to reject old moves.
+	if (GetLocalRole() == ROLE_SimulatedProxy)
+	{
+		// Timestamp
+		SetReplicatedServerLastTransformUpdateTimeStamp(SharedRepMovement.RepTimeStamp);
+
+		// Movement mode
+		if (GetReplicatedMovementMode() != SharedRepMovement.RepMovementMode)
+		{
+			SetReplicatedMovementMode(SharedRepMovement.RepMovementMode);
+			GetCharacterMovement()->bNetworkMovementModeChanged = true;
+			GetCharacterMovement()->bNetworkUpdateReceived = true;
+		}
+
+		// Location, Rotation, Velocity, etc.
+		FRepMovement& MutableRepMovement = GetReplicatedMovement_Mutable();
+		MutableRepMovement = SharedRepMovement.RepMovement;
+
+		// This also sets LastRepMovement
+		OnRep_ReplicatedMovement();
+
+		// Jump force
+		SetProxyIsJumpForceApplied(SharedRepMovement.bProxyIsJumpForceApplied);
+
+		// Crouch
+		if (IsCrouched() != SharedRepMovement.bIsCrouched)
+		{
+			SetIsCrouched(SharedRepMovement.bIsCrouched);
+			OnRep_IsCrouched();
+		}
+	}
+}
+
+FSharedRepMovement::FSharedRepMovement()
+{
+	RepMovement.LocationQuantizationLevel = EVectorQuantization::RoundTwoDecimals;
+}
+
+bool FSharedRepMovement::FillForCharacter(ACharacter* Character)
+{
+	if (USceneComponent* PawnRootComponent = Character->GetRootComponent())
+	{
+		UCharacterMovementComponent* CharacterMovement = Character->GetCharacterMovement();
+
+		RepMovement.Location = FRepMovement::RebaseOntoZeroOrigin(PawnRootComponent->GetComponentLocation(), Character);
+		RepMovement.Rotation = PawnRootComponent->GetComponentRotation();
+		RepMovement.LinearVelocity = CharacterMovement->Velocity;
+		RepMovementMode = CharacterMovement->PackNetworkMovementMode();
+		bProxyIsJumpForceApplied = Character->GetProxyIsJumpForceApplied() || (Character->JumpForceTimeRemaining > 0.0f);
+		bIsCrouched = Character->IsCrouched();
+
+		// Timestamp is sent as zero if unused
+		if ((CharacterMovement->NetworkSmoothingMode == ENetworkSmoothingMode::Linear) || CharacterMovement->bNetworkAlwaysReplicateTransformUpdateTimestamp)
+		{
+			RepTimeStamp = CharacterMovement->GetServerLastTransformUpdateTimeStamp();
+		}
+		else
+		{
+			RepTimeStamp = 0.f;
+		}
+
+		return true;
+	}
+	return false;
+}
+
+bool FSharedRepMovement::Equals(const FSharedRepMovement& Other, ACharacter* Character) const
+{
+	if (RepMovement.Location != Other.RepMovement.Location)
+	{
+		return false;
+	}
+
+	if (RepMovement.Rotation != Other.RepMovement.Rotation)
+	{
+		return false;
+	}
+
+	if (RepMovement.LinearVelocity != Other.RepMovement.LinearVelocity)
+	{
+		return false;
+	}
+
+	if (RepMovementMode != Other.RepMovementMode)
+	{
+		return false;
+	}
+
+	if (bProxyIsJumpForceApplied != Other.bProxyIsJumpForceApplied)
+	{
+		return false;
+	}
+
+	if (bIsCrouched != Other.bIsCrouched)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+bool FSharedRepMovement::NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess)
+{
+	bOutSuccess = true;
+	RepMovement.NetSerialize(Ar, Map, bOutSuccess);
+	Ar << RepMovementMode;
+	Ar << bProxyIsJumpForceApplied;
+	Ar << bIsCrouched;
+
+	// Timestamp, if non-zero.
+	uint8 bHasTimeStamp = (RepTimeStamp != 0.f);
+	Ar.SerializeBits(&bHasTimeStamp, 1);
+	if (bHasTimeStamp)
+	{
+		Ar << RepTimeStamp;
+	}
+	else
+	{
+		RepTimeStamp = 0.f;
+	}
+
+	return true;
+}

LyraStarterGame/Source/LyraGame/Character/LyraCharacter.h

@@ -0,0 +1,231 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "AbilitySystemInterface.h"
+#include "GameplayCueInterface.h"
+#include "GameplayTagAssetInterface.h"
+#include "ModularCharacter.h"
+#include "Teams/LyraTeamAgentInterface.h"
+
+#include "LyraCharacter.generated.h"
+
+#define UE_API LYRAGAME_API
+
+class AActor;
+class AController;
+class ALyraPlayerController;
+class ALyraPlayerState;
+class FLifetimeProperty;
+class IRepChangedPropertyTracker;
+class UAbilitySystemComponent;
+class UInputComponent;
+class ULyraAbilitySystemComponent;
+class ULyraCameraComponent;
+class ULyraHealthComponent;
+class ULyraPawnExtensionComponent;
+class UObject;
+struct FFrame;
+struct FGameplayTag;
+struct FGameplayTagContainer;
+
+
+/**
+ * FLyraReplicatedAcceleration: Compressed representation of acceleration
+ */
+USTRUCT()
+struct FLyraReplicatedAcceleration
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	uint8 AccelXYRadians = 0;	// Direction of XY accel component, quantized to represent [0, 2*pi]
+
+	UPROPERTY()
+	uint8 AccelXYMagnitude = 0;	//Accel rate of XY component, quantized to represent [0, MaxAcceleration]
+
+	UPROPERTY()
+	int8 AccelZ = 0;	// Raw Z accel rate component, quantized to represent [-MaxAcceleration, MaxAcceleration]
+};
+
+/** The type we use to send FastShared movement updates. */
+USTRUCT()
+struct FSharedRepMovement
+{
+	GENERATED_BODY()
+
+	FSharedRepMovement();
+
+	bool FillForCharacter(ACharacter* Character);
+	bool Equals(const FSharedRepMovement& Other, ACharacter* Character) const;
+
+	bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
+
+	UPROPERTY(Transient)
+	FRepMovement RepMovement;
+
+	UPROPERTY(Transient)
+	float RepTimeStamp = 0.0f;
+
+	UPROPERTY(Transient)
+	uint8 RepMovementMode = 0;
+
+	UPROPERTY(Transient)
+	bool bProxyIsJumpForceApplied = false;
+
+	UPROPERTY(Transient)
+	bool bIsCrouched = false;
+};
+
+template<>
+struct TStructOpsTypeTraits<FSharedRepMovement> : public TStructOpsTypeTraitsBase2<FSharedRepMovement>
+{
+	enum
+	{
+		WithNetSerializer = true,
+		WithNetSharedSerialization = true,
+	};
+};
+
+/**
+ * ALyraCharacter
+ *
+ *	The base character pawn class used by this project.
+ *	Responsible for sending events to pawn components.
+ *	New behavior should be added via pawn components when possible.
+ */
+UCLASS(MinimalAPI, Config = Game, Meta = (ShortTooltip = "The base character pawn class used by this project."))
+class ALyraCharacter : public AModularCharacter, public IAbilitySystemInterface, public IGameplayCueInterface, public IGameplayTagAssetInterface, public ILyraTeamAgentInterface
+{
+	GENERATED_BODY()
+
+public:
+
+	UE_API ALyraCharacter(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
+
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Character")
+	UE_API ALyraPlayerController* GetLyraPlayerController() const;
+
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Character")
+	UE_API ALyraPlayerState* GetLyraPlayerState() const;
+
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Character")
+	UE_API ULyraAbilitySystemComponent* GetLyraAbilitySystemComponent() const;
+	UE_API virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override;
+
+	UE_API virtual void GetOwnedGameplayTags(FGameplayTagContainer& TagContainer) const override;
+	UE_API virtual bool HasMatchingGameplayTag(FGameplayTag TagToCheck) const override;
+	UE_API virtual bool HasAllMatchingGameplayTags(const FGameplayTagContainer& TagContainer) const override;
+	UE_API virtual bool HasAnyMatchingGameplayTags(const FGameplayTagContainer& TagContainer) const override;
+
+	UE_API void ToggleCrouch();
+
+	//~AActor interface
+	UE_API virtual void PreInitializeComponents() override;
+	UE_API virtual void BeginPlay() override;
+	UE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+	UE_API virtual void Reset() override;
+	UE_API virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
+	UE_API virtual void PreReplication(IRepChangedPropertyTracker& ChangedPropertyTracker) override;
+	//~End of AActor interface
+
+	//~APawn interface
+	UE_API virtual void NotifyControllerChanged() override;
+	//~End of APawn interface
+
+	//~ILyraTeamAgentInterface interface
+	UE_API virtual void SetGenericTeamId(const FGenericTeamId& NewTeamID) override;
+	UE_API virtual FGenericTeamId GetGenericTeamId() const override;
+	UE_API virtual FOnLyraTeamIndexChangedDelegate* GetOnTeamIndexChangedDelegate() override;
+	//~End of ILyraTeamAgentInterface interface
+
+	/** RPCs that is called on frames when default property replication is skipped. This replicates a single movement update to everyone. */
+	UFUNCTION(NetMulticast, unreliable)
+	UE_API void FastSharedReplication(const FSharedRepMovement& SharedRepMovement);
+
+	// Last FSharedRepMovement we sent, to avoid sending repeatedly.
+	FSharedRepMovement LastSharedReplication;
+
+	UE_API virtual bool UpdateSharedReplication();
+
+protected:
+
+	UE_API virtual void OnAbilitySystemInitialized();
+	UE_API virtual void OnAbilitySystemUninitialized();
+
+	UE_API virtual void PossessedBy(AController* NewController) override;
+	UE_API virtual void UnPossessed() override;
+
+	UE_API virtual void OnRep_Controller() override;
+	UE_API virtual void OnRep_PlayerState() override;
+
+	UE_API virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;
+
+	UE_API void InitializeGameplayTags();
+
+	UE_API virtual void FellOutOfWorld(const class UDamageType& dmgType) override;
+
+	// Begins the death sequence for the character (disables collision, disables movement, etc...)
+	UFUNCTION()
+	UE_API virtual void OnDeathStarted(AActor* OwningActor);
+
+	// Ends the death sequence for the character (detaches controller, destroys pawn, etc...)
+	UFUNCTION()
+	UE_API virtual void OnDeathFinished(AActor* OwningActor);
+
+	UE_API void DisableMovementAndCollision();
+	UE_API void DestroyDueToDeath();
+	UE_API void UninitAndDestroy();
+
+	// Called when the death sequence for the character has completed
+	UFUNCTION(BlueprintImplementableEvent, meta=(DisplayName="OnDeathFinished"))
+	UE_API void K2_OnDeathFinished();
+
+	UE_API virtual void OnMovementModeChanged(EMovementMode PrevMovementMode, uint8 PreviousCustomMode) override;
+	UE_API void SetMovementModeTag(EMovementMode MovementMode, uint8 CustomMovementMode, bool bTagEnabled);
+
+	UE_API virtual void OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) override;
+	UE_API virtual void OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) override;
+
+	UE_API virtual bool CanJumpInternal_Implementation() const;
+
+private:
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Lyra|Character", Meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<ULyraPawnExtensionComponent> PawnExtComponent;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Lyra|Character", Meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<ULyraHealthComponent> HealthComponent;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Lyra|Character", Meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<ULyraCameraComponent> CameraComponent;
+
+	UPROPERTY(Transient, ReplicatedUsing = OnRep_ReplicatedAcceleration)
+	FLyraReplicatedAcceleration ReplicatedAcceleration;
+
+	UPROPERTY(ReplicatedUsing = OnRep_MyTeamID)
+	FGenericTeamId MyTeamID;
+
+	UPROPERTY()
+	FOnLyraTeamIndexChangedDelegate OnTeamChangedDelegate;
+
+protected:
+	// Called to determine what happens to the team ID when possession ends
+	virtual FGenericTeamId DetermineNewTeamAfterPossessionEnds(FGenericTeamId OldTeamID) const
+	{
+		// This could be changed to return, e.g., OldTeamID if you want to keep it assigned afterwards, or return an ID for some neutral faction, or etc...
+		return FGenericTeamId::NoTeam;
+	}
+
+private:
+	UFUNCTION()
+	UE_API void OnControllerChangedTeam(UObject* TeamAgent, int32 OldTeam, int32 NewTeam);
+
+	UFUNCTION()
+	UE_API void OnRep_ReplicatedAcceleration();
+
+	UFUNCTION()
+	UE_API void OnRep_MyTeamID(FGenericTeamId OldTeamID);
+};
+
+#undef UE_API

LyraStarterGame/Source/LyraGame/Character/LyraCharacterMovementComponent.cpp

@@ -0,0 +1,131 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraCharacterMovementComponent.h"
+
+#include "AbilitySystemComponent.h"
+#include "AbilitySystemGlobals.h"
+#include "Components/CapsuleComponent.h"
+#include "Engine/World.h"
+#include "GameFramework/Character.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraCharacterMovementComponent)
+
+UE_DEFINE_GAMEPLAY_TAG(TAG_Gameplay_MovementStopped, "Gameplay.MovementStopped");
+
+namespace LyraCharacter
+{
+	static float GroundTraceDistance = 100000.0f;
+	FAutoConsoleVariableRef CVar_GroundTraceDistance(TEXT("LyraCharacter.GroundTraceDistance"), GroundTraceDistance, TEXT("Distance to trace down when generating ground information."), ECVF_Cheat);
+};
+
+
+ULyraCharacterMovementComponent::ULyraCharacterMovementComponent(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+void ULyraCharacterMovementComponent::SimulateMovement(float DeltaTime)
+{
+	if (bHasReplicatedAcceleration)
+	{
+		// Preserve our replicated acceleration
+		const FVector OriginalAcceleration = Acceleration;
+		Super::SimulateMovement(DeltaTime);
+		Acceleration = OriginalAcceleration;
+	}
+	else
+	{
+		Super::SimulateMovement(DeltaTime);
+	}
+}
+
+bool ULyraCharacterMovementComponent::CanAttemptJump() const
+{
+	// Same as UCharacterMovementComponent's implementation but without the crouch check
+	return IsJumpAllowed() &&
+		(IsMovingOnGround() || IsFalling()); // Falling included for double-jump and non-zero jump hold time, but validated by character.
+}
+
+void ULyraCharacterMovementComponent::InitializeComponent()
+{
+	Super::InitializeComponent();
+}
+
+const FLyraCharacterGroundInfo& ULyraCharacterMovementComponent::GetGroundInfo()
+{
+	if (!CharacterOwner || (GFrameCounter == CachedGroundInfo.LastUpdateFrame))
+	{
+		return CachedGroundInfo;
+	}
+
+	if (MovementMode == MOVE_Walking)
+	{
+		CachedGroundInfo.GroundHitResult = CurrentFloor.HitResult;
+		CachedGroundInfo.GroundDistance = 0.0f;
+	}
+	else
+	{
+		const UCapsuleComponent* CapsuleComp = CharacterOwner->GetCapsuleComponent();
+		check(CapsuleComp);
+
+		const float CapsuleHalfHeight = CapsuleComp->GetUnscaledCapsuleHalfHeight();
+		const ECollisionChannel CollisionChannel = (UpdatedComponent ? UpdatedComponent->GetCollisionObjectType() : ECC_Pawn);
+		const FVector TraceStart(GetActorLocation());
+		const FVector TraceEnd(TraceStart.X, TraceStart.Y, (TraceStart.Z - LyraCharacter::GroundTraceDistance - CapsuleHalfHeight));
+
+		FCollisionQueryParams QueryParams(SCENE_QUERY_STAT(LyraCharacterMovementComponent_GetGroundInfo), false, CharacterOwner);
+		FCollisionResponseParams ResponseParam;
+		InitCollisionParams(QueryParams, ResponseParam);
+
+		FHitResult HitResult;
+		GetWorld()->LineTraceSingleByChannel(HitResult, TraceStart, TraceEnd, CollisionChannel, QueryParams, ResponseParam);
+
+		CachedGroundInfo.GroundHitResult = HitResult;
+		CachedGroundInfo.GroundDistance = LyraCharacter::GroundTraceDistance;
+
+		if (MovementMode == MOVE_NavWalking)
+		{
+			CachedGroundInfo.GroundDistance = 0.0f;
+		}
+		else if (HitResult.bBlockingHit)
+		{
+			CachedGroundInfo.GroundDistance = FMath::Max((HitResult.Distance - CapsuleHalfHeight), 0.0f);
+		}
+	}
+
+	CachedGroundInfo.LastUpdateFrame = GFrameCounter;
+
+	return CachedGroundInfo;
+}
+
+void ULyraCharacterMovementComponent::SetReplicatedAcceleration(const FVector& InAcceleration)
+{
+	bHasReplicatedAcceleration = true;
+	Acceleration = InAcceleration;
+}
+
+FRotator ULyraCharacterMovementComponent::GetDeltaRotation(float DeltaTime) const
+{
+	if (UAbilitySystemComponent* ASC = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(GetOwner()))
+	{
+		if (ASC->HasMatchingGameplayTag(TAG_Gameplay_MovementStopped))
+		{
+			return FRotator(0,0,0);
+		}
+	}
+
+	return Super::GetDeltaRotation(DeltaTime);
+}
+
+float ULyraCharacterMovementComponent::GetMaxSpeed() const
+{
+	if (UAbilitySystemComponent* ASC = UAbilitySystemGlobals::GetAbilitySystemComponentFromActor(GetOwner()))
+	{
+		if (ASC->HasMatchingGameplayTag(TAG_Gameplay_MovementStopped))
+		{
+			return 0;
+		}
+	}
+
+	return Super::GetMaxSpeed();
+}

LyraStarterGame/Source/LyraGame/Character/LyraCharacterMovementComponent.h

@@ -0,0 +1,84 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "GameFramework/CharacterMovementComponent.h"
+#include "NativeGameplayTags.h"
+
+#include "LyraCharacterMovementComponent.generated.h"
+
+#define UE_API LYRAGAME_API
+
+class UObject;
+struct FFrame;
+
+LYRAGAME_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Gameplay_MovementStopped);
+
+/**
+ * FLyraCharacterGroundInfo
+ *
+ *	Information about the ground under the character.  It only gets updated as needed.
+ */
+USTRUCT(BlueprintType)
+struct FLyraCharacterGroundInfo
+{
+	GENERATED_BODY()
+
+	FLyraCharacterGroundInfo()
+		: LastUpdateFrame(0)
+		, GroundDistance(0.0f)
+	{}
+
+	uint64 LastUpdateFrame;
+
+	UPROPERTY(BlueprintReadOnly)
+	FHitResult GroundHitResult;
+
+	UPROPERTY(BlueprintReadOnly)
+	float GroundDistance;
+};
+
+
+/**
+ * ULyraCharacterMovementComponent
+ *
+ *	The base character movement component class used by this project.
+ */
+UCLASS(MinimalAPI, Config = Game)
+class ULyraCharacterMovementComponent : public UCharacterMovementComponent
+{
+	GENERATED_BODY()
+
+public:
+
+	UE_API ULyraCharacterMovementComponent(const FObjectInitializer& ObjectInitializer);
+
+	UE_API virtual void SimulateMovement(float DeltaTime) override;
+
+	UE_API virtual bool CanAttemptJump() const override;
+
+	// Returns the current ground info.  Calling this will update the ground info if it's out of date.
+	UFUNCTION(BlueprintCallable, Category = "Lyra|CharacterMovement")
+	UE_API const FLyraCharacterGroundInfo& GetGroundInfo();
+
+	UE_API void SetReplicatedAcceleration(const FVector& InAcceleration);
+
+	//~UMovementComponent interface
+	UE_API virtual FRotator GetDeltaRotation(float DeltaTime) const override;
+	UE_API virtual float GetMaxSpeed() const override;
+	//~End of UMovementComponent interface
+
+protected:
+
+	UE_API virtual void InitializeComponent() override;
+
+protected:
+
+	// Cached ground info for the character.  Do not access this directly!  It's only updated when accessed via GetGroundInfo().
+	FLyraCharacterGroundInfo CachedGroundInfo;
+
+	UPROPERTY(Transient)
+	bool bHasReplicatedAcceleration = false;
+};
+
+#undef UE_API

LyraStarterGame/Source/LyraGame/Character/LyraCharacterWithAbilities.cpp

@@ -0,0 +1,39 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraCharacterWithAbilities.h"
+
+#include "AbilitySystem/Attributes/LyraCombatSet.h"
+#include "AbilitySystem/Attributes/LyraHealthSet.h"
+#include "AbilitySystem/LyraAbilitySystemComponent.h"
+#include "Async/TaskGraphInterfaces.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraCharacterWithAbilities)
+
+ALyraCharacterWithAbilities::ALyraCharacterWithAbilities(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+	AbilitySystemComponent = ObjectInitializer.CreateDefaultSubobject<ULyraAbilitySystemComponent>(this, TEXT("AbilitySystemComponent"));
+	AbilitySystemComponent->SetIsReplicated(true);
+	AbilitySystemComponent->SetReplicationMode(EGameplayEffectReplicationMode::Mixed);
+
+	// These attribute sets will be detected by AbilitySystemComponent::InitializeComponent. Keeping a reference so that the sets don't get garbage collected before that.
+	HealthSet = CreateDefaultSubobject<ULyraHealthSet>(TEXT("HealthSet"));
+	CombatSet = CreateDefaultSubobject<ULyraCombatSet>(TEXT("CombatSet"));
+
+	// AbilitySystemComponent needs to be updated at a high frequency.
+	SetNetUpdateFrequency(100.0f);
+}
+
+void ALyraCharacterWithAbilities::PostInitializeComponents()
+{
+	Super::PostInitializeComponents();
+
+	check(AbilitySystemComponent);
+	AbilitySystemComponent->InitAbilityActorInfo(this, this);
+}
+
+UAbilitySystemComponent* ALyraCharacterWithAbilities::GetAbilitySystemComponent() const
+{
+	return AbilitySystemComponent;
+}
+

LyraStarterGame/Source/LyraGame/Character/LyraCharacterWithAbilities.h

@@ -0,0 +1,43 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Character/LyraCharacter.h"
+
+#include "LyraCharacterWithAbilities.generated.h"
+
+#define UE_API LYRAGAME_API
+
+class UAbilitySystemComponent;
+class ULyraAbilitySystemComponent;
+class UObject;
+
+// ALyraCharacter typically gets the ability system component from the possessing player state
+// This represents a character with a self-contained ability system component.
+UCLASS(MinimalAPI, Blueprintable)
+class ALyraCharacterWithAbilities : public ALyraCharacter
+{
+	GENERATED_BODY()
+
+public:
+	UE_API ALyraCharacterWithAbilities(const FObjectInitializer& ObjectInitializer);
+
+	UE_API virtual void PostInitializeComponents() override;
+
+	UE_API virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override;
+
+private:
+
+	// The ability system component sub-object used by player characters.
+	UPROPERTY(VisibleAnywhere, Category = "Lyra|PlayerState")
+	TObjectPtr<ULyraAbilitySystemComponent> AbilitySystemComponent;
+	
+	// Health attribute set used by this actor.
+	UPROPERTY()
+	TObjectPtr<const class ULyraHealthSet> HealthSet;
+	// Combat attribute set used by this actor.
+	UPROPERTY()
+	TObjectPtr<const class ULyraCombatSet> CombatSet;
+};
+
+#undef UE_API

LyraStarterGame/Source/LyraGame/Character/LyraHealthComponent.cpp

@@ -0,0 +1,312 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "Character/LyraHealthComponent.h"
+
+#include "AbilitySystem/Attributes/LyraAttributeSet.h"
+#include "LyraLogChannels.h"
+#include "System/LyraAssetManager.h"
+#include "System/LyraGameData.h"
+#include "LyraGameplayTags.h"
+#include "Net/UnrealNetwork.h"
+#include "GameplayEffectExtension.h"
+#include "AbilitySystem/LyraAbilitySystemComponent.h"
+#include "AbilitySystem/Attributes/LyraHealthSet.h"
+#include "Messages/LyraVerbMessage.h"
+#include "Messages/LyraVerbMessageHelpers.h"
+#include "GameFramework/GameplayMessageSubsystem.h"
+#include "GameFramework/PlayerState.h"
+#include "Engine/World.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraHealthComponent)
+
+UE_DEFINE_GAMEPLAY_TAG_STATIC(TAG_Lyra_Elimination_Message, "Lyra.Elimination.Message");
+
+
+ULyraHealthComponent::ULyraHealthComponent(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+	PrimaryComponentTick.bStartWithTickEnabled = false;
+	PrimaryComponentTick.bCanEverTick = false;
+
+	SetIsReplicatedByDefault(true);
+
+	AbilitySystemComponent = nullptr;
+	HealthSet = nullptr;
+	DeathState = ELyraDeathState::NotDead;
+}
+
+void ULyraHealthComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
+{
+	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+
+	DOREPLIFETIME(ULyraHealthComponent, DeathState);
+}
+
+void ULyraHealthComponent::OnUnregister()
+{
+	UninitializeFromAbilitySystem();
+
+	Super::OnUnregister();
+}
+
+void ULyraHealthComponent::InitializeWithAbilitySystem(ULyraAbilitySystemComponent* InASC)
+{
+	AActor* Owner = GetOwner();
+	check(Owner);
+
+	if (AbilitySystemComponent)
+	{
+		UE_LOG(LogLyra, Error, TEXT("LyraHealthComponent: Health component for owner [%s] has already been initialized with an ability system."), *GetNameSafe(Owner));
+		return;
+	}
+
+	AbilitySystemComponent = InASC;
+	if (!AbilitySystemComponent)
+	{
+		UE_LOG(LogLyra, Error, TEXT("LyraHealthComponent: Cannot initialize health component for owner [%s] with NULL ability system."), *GetNameSafe(Owner));
+		return;
+	}
+
+	HealthSet = AbilitySystemComponent->GetSet<ULyraHealthSet>();
+	if (!HealthSet)
+	{
+		UE_LOG(LogLyra, Error, TEXT("LyraHealthComponent: Cannot initialize health component for owner [%s] with NULL health set on the ability system."), *GetNameSafe(Owner));
+		return;
+	}
+
+	// Register to listen for attribute changes.
+	HealthSet->OnHealthChanged.AddUObject(this, &ThisClass::HandleHealthChanged);
+	HealthSet->OnMaxHealthChanged.AddUObject(this, &ThisClass::HandleMaxHealthChanged);
+	HealthSet->OnOutOfHealth.AddUObject(this, &ThisClass::HandleOutOfHealth);
+
+	// TEMP: Reset attributes to default values.  Eventually this will be driven by a spread sheet.
+	AbilitySystemComponent->SetNumericAttributeBase(ULyraHealthSet::GetHealthAttribute(), HealthSet->GetMaxHealth());
+
+	ClearGameplayTags();
+
+	OnHealthChanged.Broadcast(this, HealthSet->GetHealth(), HealthSet->GetHealth(), nullptr);
+	OnMaxHealthChanged.Broadcast(this, HealthSet->GetHealth(), HealthSet->GetHealth(), nullptr);
+}
+
+void ULyraHealthComponent::UninitializeFromAbilitySystem()
+{
+	ClearGameplayTags();
+
+	if (HealthSet)
+	{
+		HealthSet->OnHealthChanged.RemoveAll(this);
+		HealthSet->OnMaxHealthChanged.RemoveAll(this);
+		HealthSet->OnOutOfHealth.RemoveAll(this);
+	}
+
+	HealthSet = nullptr;
+	AbilitySystemComponent = nullptr;
+}
+
+void ULyraHealthComponent::ClearGameplayTags()
+{
+	if (AbilitySystemComponent)
+	{
+		AbilitySystemComponent->SetLooseGameplayTagCount(LyraGameplayTags::Status_Death_Dying, 0);
+		AbilitySystemComponent->SetLooseGameplayTagCount(LyraGameplayTags::Status_Death_Dead, 0);
+	}
+}
+
+float ULyraHealthComponent::GetHealth() const
+{
+	return (HealthSet ? HealthSet->GetHealth() : 0.0f);
+}
+
+float ULyraHealthComponent::GetMaxHealth() const
+{
+	return (HealthSet ? HealthSet->GetMaxHealth() : 0.0f);
+}
+
+float ULyraHealthComponent::GetHealthNormalized() const
+{
+	if (HealthSet)
+	{
+		const float Health = HealthSet->GetHealth();
+		const float MaxHealth = HealthSet->GetMaxHealth();
+
+		return ((MaxHealth > 0.0f) ? (Health / MaxHealth) : 0.0f);
+	}
+
+	return 0.0f;
+}
+
+void ULyraHealthComponent::HandleHealthChanged(AActor* DamageInstigator, AActor* DamageCauser, const FGameplayEffectSpec* DamageEffectSpec, float DamageMagnitude, float OldValue, float NewValue)
+{
+	OnHealthChanged.Broadcast(this, OldValue, NewValue, DamageInstigator);
+}
+
+void ULyraHealthComponent::HandleMaxHealthChanged(AActor* DamageInstigator, AActor* DamageCauser, const FGameplayEffectSpec* DamageEffectSpec, float DamageMagnitude, float OldValue, float NewValue)
+{
+	OnMaxHealthChanged.Broadcast(this, OldValue, NewValue, DamageInstigator);
+}
+
+void ULyraHealthComponent::HandleOutOfHealth(AActor* DamageInstigator, AActor* DamageCauser, const FGameplayEffectSpec* DamageEffectSpec, float DamageMagnitude, float OldValue, float NewValue)
+{
+#if WITH_SERVER_CODE
+	if (AbilitySystemComponent && DamageEffectSpec)
+	{
+		// Send the "GameplayEvent.Death" gameplay event through the owner's ability system.  This can be used to trigger a death gameplay ability.
+		{
+			FGameplayEventData Payload;
+			Payload.EventTag = LyraGameplayTags::GameplayEvent_Death;
+			Payload.Instigator = DamageInstigator;
+			Payload.Target = AbilitySystemComponent->GetAvatarActor();
+			Payload.OptionalObject = DamageEffectSpec->Def;
+			Payload.ContextHandle = DamageEffectSpec->GetEffectContext();
+			Payload.InstigatorTags = *DamageEffectSpec->CapturedSourceTags.GetAggregatedTags();
+			Payload.TargetTags = *DamageEffectSpec->CapturedTargetTags.GetAggregatedTags();
+			Payload.EventMagnitude = DamageMagnitude;
+
+			FScopedPredictionWindow NewScopedWindow(AbilitySystemComponent, true);
+			AbilitySystemComponent->HandleGameplayEvent(Payload.EventTag, &Payload);
+		}
+
+		// Send a standardized verb message that other systems can observe
+		{
+			FLyraVerbMessage Message;
+			Message.Verb = TAG_Lyra_Elimination_Message;
+			Message.Instigator = DamageInstigator;
+			Message.InstigatorTags = *DamageEffectSpec->CapturedSourceTags.GetAggregatedTags();
+			Message.Target = ULyraVerbMessageHelpers::GetPlayerStateFromObject(AbilitySystemComponent->GetAvatarActor());
+			Message.TargetTags = *DamageEffectSpec->CapturedTargetTags.GetAggregatedTags();
+			//@TODO: Fill out context tags, and any non-ability-system source/instigator tags
+			//@TODO: Determine if it's an opposing team kill, self-own, team kill, etc...
+
+			UGameplayMessageSubsystem& MessageSystem = UGameplayMessageSubsystem::Get(GetWorld());
+			MessageSystem.BroadcastMessage(Message.Verb, Message);
+		}
+
+		//@TODO: assist messages (could compute from damage dealt elsewhere)?
+	}
+
+#endif // #if WITH_SERVER_CODE
+}
+
+void ULyraHealthComponent::OnRep_DeathState(ELyraDeathState OldDeathState)
+{
+	const ELyraDeathState NewDeathState = DeathState;
+
+	// Revert the death state for now since we rely on StartDeath and FinishDeath to change it.
+	DeathState = OldDeathState;
+
+	if (OldDeathState > NewDeathState)
+	{
+		// The server is trying to set us back but we've already predicted past the server state.
+		UE_LOG(LogLyra, Warning, TEXT("LyraHealthComponent: Predicted past server death state [%d] -> [%d] for owner [%s]."), (uint8)OldDeathState, (uint8)NewDeathState, *GetNameSafe(GetOwner()));
+		return;
+	}
+
+	if (OldDeathState == ELyraDeathState::NotDead)
+	{
+		if (NewDeathState == ELyraDeathState::DeathStarted)
+		{
+			StartDeath();
+		}
+		else if (NewDeathState == ELyraDeathState::DeathFinished)
+		{
+			StartDeath();
+			FinishDeath();
+		}
+		else
+		{
+			UE_LOG(LogLyra, Error, TEXT("LyraHealthComponent: Invalid death transition [%d] -> [%d] for owner [%s]."), (uint8)OldDeathState, (uint8)NewDeathState, *GetNameSafe(GetOwner()));
+		}
+	}
+	else if (OldDeathState == ELyraDeathState::DeathStarted)
+	{
+		if (NewDeathState == ELyraDeathState::DeathFinished)
+		{
+			FinishDeath();
+		}
+		else
+		{
+			UE_LOG(LogLyra, Error, TEXT("LyraHealthComponent: Invalid death transition [%d] -> [%d] for owner [%s]."), (uint8)OldDeathState, (uint8)NewDeathState, *GetNameSafe(GetOwner()));
+		}
+	}
+
+	ensureMsgf((DeathState == NewDeathState), TEXT("LyraHealthComponent: Death transition failed [%d] -> [%d] for owner [%s]."), (uint8)OldDeathState, (uint8)NewDeathState, *GetNameSafe(GetOwner()));
+}
+
+void ULyraHealthComponent::StartDeath()
+{
+	if (DeathState != ELyraDeathState::NotDead)
+	{
+		return;
+	}
+
+	DeathState = ELyraDeathState::DeathStarted;
+
+	if (AbilitySystemComponent)
+	{
+		AbilitySystemComponent->SetLooseGameplayTagCount(LyraGameplayTags::Status_Death_Dying, 1);
+	}
+
+	AActor* Owner = GetOwner();
+	check(Owner);
+
+	OnDeathStarted.Broadcast(Owner);
+
+	Owner->ForceNetUpdate();
+}
+
+void ULyraHealthComponent::FinishDeath()
+{
+	if (DeathState != ELyraDeathState::DeathStarted)
+	{
+		return;
+	}
+
+	DeathState = ELyraDeathState::DeathFinished;
+
+	if (AbilitySystemComponent)
+	{
+		AbilitySystemComponent->SetLooseGameplayTagCount(LyraGameplayTags::Status_Death_Dead, 1);
+	}
+
+	AActor* Owner = GetOwner();
+	check(Owner);
+
+	OnDeathFinished.Broadcast(Owner);
+
+	Owner->ForceNetUpdate();
+}
+
+void ULyraHealthComponent::DamageSelfDestruct(bool bFellOutOfWorld)
+{
+	if ((DeathState == ELyraDeathState::NotDead) && AbilitySystemComponent)
+	{
+		const TSubclassOf<UGameplayEffect> DamageGE = ULyraAssetManager::GetSubclass(ULyraGameData::Get().DamageGameplayEffect_SetByCaller);
+		if (!DamageGE)
+		{
+			UE_LOG(LogLyra, Error, TEXT("LyraHealthComponent: DamageSelfDestruct failed for owner [%s]. Unable to find gameplay effect [%s]."), *GetNameSafe(GetOwner()), *ULyraGameData::Get().DamageGameplayEffect_SetByCaller.GetAssetName());
+			return;
+		}
+
+		FGameplayEffectSpecHandle SpecHandle = AbilitySystemComponent->MakeOutgoingSpec(DamageGE, 1.0f, AbilitySystemComponent->MakeEffectContext());
+		FGameplayEffectSpec* Spec = SpecHandle.Data.Get();
+
+		if (!Spec)
+		{
+			UE_LOG(LogLyra, Error, TEXT("LyraHealthComponent: DamageSelfDestruct failed for owner [%s]. Unable to make outgoing spec for [%s]."), *GetNameSafe(GetOwner()), *GetNameSafe(DamageGE));
+			return;
+		}
+
+		Spec->AddDynamicAssetTag(TAG_Gameplay_DamageSelfDestruct);
+
+		if (bFellOutOfWorld)
+		{
+			Spec->AddDynamicAssetTag(TAG_Gameplay_FellOutOfWorld);
+		}
+
+		const float DamageAmount = GetMaxHealth();
+
+		Spec->SetSetByCallerMagnitude(LyraGameplayTags::SetByCaller_Damage, DamageAmount);
+		AbilitySystemComponent->ApplyGameplayEffectSpecToSelf(*Spec);
+	}
+}
+

LyraStarterGame/Source/LyraGame/Character/LyraHealthComponent.h

@@ -0,0 +1,135 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Components/GameFrameworkComponent.h"
+
+#include "LyraHealthComponent.generated.h"
+
+#define UE_API LYRAGAME_API
+
+class ULyraHealthComponent;
+
+class ULyraAbilitySystemComponent;
+class ULyraHealthSet;
+class UObject;
+struct FFrame;
+struct FGameplayEffectSpec;
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLyraHealth_DeathEvent, AActor*, OwningActor);
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FLyraHealth_AttributeChanged, ULyraHealthComponent*, HealthComponent, float, OldValue, float, NewValue, AActor*, Instigator);
+
+/**
+ * ELyraDeathState
+ *
+ *	Defines current state of death.
+ */
+UENUM(BlueprintType)
+enum class ELyraDeathState : uint8
+{
+	NotDead = 0,
+	DeathStarted,
+	DeathFinished
+};
+
+
+/**
+ * ULyraHealthComponent
+ *
+ *	An actor component used to handle anything related to health.
+ */
+UCLASS(MinimalAPI, Blueprintable, Meta=(BlueprintSpawnableComponent))
+class ULyraHealthComponent : public UGameFrameworkComponent
+{
+	GENERATED_BODY()
+
+public:
+
+	UE_API ULyraHealthComponent(const FObjectInitializer& ObjectInitializer);
+
+	// Returns the health component if one exists on the specified actor.
+	UFUNCTION(BlueprintPure, Category = "Lyra|Health")
+	static ULyraHealthComponent* FindHealthComponent(const AActor* Actor) { return (Actor ? Actor->FindComponentByClass<ULyraHealthComponent>() : nullptr); }
+
+	// Initialize the component using an ability system component.
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Health")
+	UE_API void InitializeWithAbilitySystem(ULyraAbilitySystemComponent* InASC);
+
+	// Uninitialize the component, clearing any references to the ability system.
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Health")
+	UE_API void UninitializeFromAbilitySystem();
+
+	// Returns the current health value.
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Health")
+	UE_API float GetHealth() const;
+
+	// Returns the current maximum health value.
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Health")
+	UE_API float GetMaxHealth() const;
+
+	// Returns the current health in the range [0.0, 1.0].
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Health")
+	UE_API float GetHealthNormalized() const;
+
+	UFUNCTION(BlueprintCallable, Category = "Lyra|Health")
+	ELyraDeathState GetDeathState() const { return DeathState; }
+
+	UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "Lyra|Health", Meta = (ExpandBoolAsExecs = "ReturnValue"))
+	bool IsDeadOrDying() const { return (DeathState > ELyraDeathState::NotDead); }
+
+	// Begins the death sequence for the owner.
+	UE_API virtual void StartDeath();
+
+	// Ends the death sequence for the owner.
+	UE_API virtual void FinishDeath();
+
+	// Applies enough damage to kill the owner.
+	UE_API virtual void DamageSelfDestruct(bool bFellOutOfWorld = false);
+
+public:
+
+	// Delegate fired when the health value has changed. This is called on the client but the instigator may not be valid
+	UPROPERTY(BlueprintAssignable)
+	FLyraHealth_AttributeChanged OnHealthChanged;
+
+	// Delegate fired when the max health value has changed. This is called on the client but the instigator may not be valid
+	UPROPERTY(BlueprintAssignable)
+	FLyraHealth_AttributeChanged OnMaxHealthChanged;
+
+	// Delegate fired when the death sequence has started.
+	UPROPERTY(BlueprintAssignable)
+	FLyraHealth_DeathEvent OnDeathStarted;
+
+	// Delegate fired when the death sequence has finished.
+	UPROPERTY(BlueprintAssignable)
+	FLyraHealth_DeathEvent OnDeathFinished;
+
+protected:
+
+	UE_API virtual void OnUnregister() override;
+
+	UE_API void ClearGameplayTags();
+
+	UE_API virtual void HandleHealthChanged(AActor* DamageInstigator, AActor* DamageCauser, const FGameplayEffectSpec* DamageEffectSpec, float DamageMagnitude, float OldValue, float NewValue);
+	UE_API virtual void HandleMaxHealthChanged(AActor* DamageInstigator, AActor* DamageCauser, const FGameplayEffectSpec* DamageEffectSpec, float DamageMagnitude, float OldValue, float NewValue);
+	UE_API virtual void HandleOutOfHealth(AActor* DamageInstigator, AActor* DamageCauser, const FGameplayEffectSpec* DamageEffectSpec, float DamageMagnitude, float OldValue, float NewValue);
+
+	UFUNCTION()
+	UE_API virtual void OnRep_DeathState(ELyraDeathState OldDeathState);
+
+protected:
+
+	// Ability system used by this component.
+	UPROPERTY()
+	TObjectPtr<ULyraAbilitySystemComponent> AbilitySystemComponent;
+
+	// Health set used by this component.
+	UPROPERTY()
+	TObjectPtr<const ULyraHealthSet> HealthSet;
+
+	// Replicated state used to handle dying.
+	UPROPERTY(ReplicatedUsing = OnRep_DeathState)
+	ELyraDeathState DeathState;
+};
+
+#undef UE_API

LyraStarterGame/Source/LyraGame/Character/LyraHeroComponent.cpp

@@ -0,0 +1,512 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraHeroComponent.h"
+#include "Components/GameFrameworkComponentDelegates.h"
+#include "Logging/MessageLog.h"
+#include "LyraLogChannels.h"
+#include "EnhancedInputSubsystems.h"
+#include "Player/LyraPlayerController.h"
+#include "Player/LyraPlayerState.h"
+#include "Player/LyraLocalPlayer.h"
+#include "Character/LyraPawnExtensionComponent.h"
+#include "Character/LyraPawnData.h"
+#include "Character/LyraCharacter.h"
+#include "AbilitySystem/LyraAbilitySystemComponent.h"
+#include "Input/LyraInputConfig.h"
+#include "Input/LyraInputComponent.h"
+#include "Camera/LyraCameraComponent.h"
+#include "LyraGameplayTags.h"
+#include "Components/GameFrameworkComponentManager.h"
+#include "PlayerMappableInputConfig.h"
+#include "Camera/LyraCameraMode.h"
+#include "UserSettings/EnhancedInputUserSettings.h"
+#include "InputMappingContext.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraHeroComponent)
+
+#if WITH_EDITOR
+#include "Misc/UObjectToken.h"
+#endif	// WITH_EDITOR
+
+namespace LyraHero
+{
+	static const float LookYawRate = 300.0f;
+	static const float LookPitchRate = 165.0f;
+};
+
+const FName ULyraHeroComponent::NAME_BindInputsNow("BindInputsNow");
+const FName ULyraHeroComponent::NAME_ActorFeatureName("Hero");
+
+ULyraHeroComponent::ULyraHeroComponent(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+	AbilityCameraMode = nullptr;
+	bReadyToBindInputs = false;
+}
+
+void ULyraHeroComponent::OnRegister()
+{
+	Super::OnRegister();
+
+	if (!GetPawn<APawn>())
+	{
+		UE_LOG(LogLyra, Error, TEXT("[ULyraHeroComponent::OnRegister] This component has been added to a blueprint whose base class is not a Pawn. To use this component, it MUST be placed on a Pawn Blueprint."));
+
+#if WITH_EDITOR
+		if (GIsEditor)
+		{
+			static const FText Message = NSLOCTEXT("LyraHeroComponent", "NotOnPawnError", "has been added to a blueprint whose base class is not a Pawn. To use this component, it MUST be placed on a Pawn Blueprint. This will cause a crash if you PIE!");
+			static const FName HeroMessageLogName = TEXT("LyraHeroComponent");
+			
+			FMessageLog(HeroMessageLogName).Error()
+				->AddToken(FUObjectToken::Create(this, FText::FromString(GetNameSafe(this))))
+				->AddToken(FTextToken::Create(Message));
+				
+			FMessageLog(HeroMessageLogName).Open();
+		}
+#endif
+	}
+	else
+	{
+		// Register with the init state system early, this will only work if this is a game world
+		RegisterInitStateFeature();
+	}
+}
+
+bool ULyraHeroComponent::CanChangeInitState(UGameFrameworkComponentManager* Manager, FGameplayTag CurrentState, FGameplayTag DesiredState) const
+{
+	check(Manager);
+
+	APawn* Pawn = GetPawn<APawn>();
+
+	if (!CurrentState.IsValid() && DesiredState == LyraGameplayTags::InitState_Spawned)
+	{
+		// As long as we have a real pawn, let us transition
+		if (Pawn)
+		{
+			return true;
+		}
+	}
+	else if (CurrentState == LyraGameplayTags::InitState_Spawned && DesiredState == LyraGameplayTags::InitState_DataAvailable)
+	{
+		// The player state is required.
+		if (!GetPlayerState<ALyraPlayerState>())
+		{
+			return false;
+		}
+
+		// If we're authority or autonomous, we need to wait for a controller with registered ownership of the player state.
+		if (Pawn->GetLocalRole() != ROLE_SimulatedProxy)
+		{
+			AController* Controller = GetController<AController>();
+
+			const bool bHasControllerPairedWithPS = (Controller != nullptr) && \
+				(Controller->PlayerState != nullptr) && \
+				(Controller->PlayerState->GetOwner() == Controller);
+
+			if (!bHasControllerPairedWithPS)
+			{
+				return false;
+			}
+		}
+
+		const bool bIsLocallyControlled = Pawn->IsLocallyControlled();
+		const bool bIsBot = Pawn->IsBotControlled();
+
+		if (bIsLocallyControlled && !bIsBot)
+		{
+			ALyraPlayerController* LyraPC = GetController<ALyraPlayerController>();
+
+			// The input component and local player is required when locally controlled.
+			if (!Pawn->InputComponent || !LyraPC || !LyraPC->GetLocalPlayer())
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+	else if (CurrentState == LyraGameplayTags::InitState_DataAvailable && DesiredState == LyraGameplayTags::InitState_DataInitialized)
+	{
+		// Wait for player state and extension component
+		ALyraPlayerState* LyraPS = GetPlayerState<ALyraPlayerState>();
+
+		return LyraPS && Manager->HasFeatureReachedInitState(Pawn, ULyraPawnExtensionComponent::NAME_ActorFeatureName, LyraGameplayTags::InitState_DataInitialized);
+	}
+	else if (CurrentState == LyraGameplayTags::InitState_DataInitialized && DesiredState == LyraGameplayTags::InitState_GameplayReady)
+	{
+		// TODO add ability initialization checks?
+		return true;
+	}
+
+	return false;
+}
+
+void ULyraHeroComponent::HandleChangeInitState(UGameFrameworkComponentManager* Manager, FGameplayTag CurrentState, FGameplayTag DesiredState)
+{
+	if (CurrentState == LyraGameplayTags::InitState_DataAvailable && DesiredState == LyraGameplayTags::InitState_DataInitialized)
+	{
+		APawn* Pawn = GetPawn<APawn>();
+		ALyraPlayerState* LyraPS = GetPlayerState<ALyraPlayerState>();
+		if (!ensure(Pawn && LyraPS))
+		{
+			return;
+		}
+
+		const ULyraPawnData* PawnData = nullptr;
+
+		if (ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
+		{
+			PawnData = PawnExtComp->GetPawnData<ULyraPawnData>();
+
+			// The player state holds the persistent data for this player (state that persists across deaths and multiple pawns).
+			// The ability system component and attribute sets live on the player state.
+			PawnExtComp->InitializeAbilitySystem(LyraPS->GetLyraAbilitySystemComponent(), LyraPS);
+		}
+
+		if (ALyraPlayerController* LyraPC = GetController<ALyraPlayerController>())
+		{
+			if (Pawn->InputComponent != nullptr)
+			{
+				InitializePlayerInput(Pawn->InputComponent);
+			}
+		}
+
+		// Hook up the delegate for all pawns, in case we spectate later
+		if (PawnData)
+		{
+			if (ULyraCameraComponent* CameraComponent = ULyraCameraComponent::FindCameraComponent(Pawn))
+			{
+				CameraComponent->DetermineCameraModeDelegate.BindUObject(this, &ThisClass::DetermineCameraMode);
+			}
+		}
+	}
+}
+
+void ULyraHeroComponent::OnActorInitStateChanged(const FActorInitStateChangedParams& Params)
+{
+	if (Params.FeatureName == ULyraPawnExtensionComponent::NAME_ActorFeatureName)
+	{
+		if (Params.FeatureState == LyraGameplayTags::InitState_DataInitialized)
+		{
+			// If the extension component says all all other components are initialized, try to progress to next state
+			CheckDefaultInitialization();
+		}
+	}
+}
+
+void ULyraHeroComponent::CheckDefaultInitialization()
+{
+	static const TArray<FGameplayTag> StateChain = { LyraGameplayTags::InitState_Spawned, LyraGameplayTags::InitState_DataAvailable, LyraGameplayTags::InitState_DataInitialized, LyraGameplayTags::InitState_GameplayReady };
+
+	// This will try to progress from spawned (which is only set in BeginPlay) through the data initialization stages until it gets to gameplay ready
+	ContinueInitStateChain(StateChain);
+}
+
+void ULyraHeroComponent::BeginPlay()
+{
+	Super::BeginPlay();
+
+	// Listen for when the pawn extension component changes init state
+	BindOnActorInitStateChanged(ULyraPawnExtensionComponent::NAME_ActorFeatureName, FGameplayTag(), false);
+
+	// Notifies that we are done spawning, then try the rest of initialization
+	ensure(TryToChangeInitState(LyraGameplayTags::InitState_Spawned));
+	CheckDefaultInitialization();
+}
+
+void ULyraHeroComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	UnregisterInitStateFeature();
+
+	Super::EndPlay(EndPlayReason);
+}
+
+void ULyraHeroComponent::InitializePlayerInput(UInputComponent* PlayerInputComponent)
+{
+	check(PlayerInputComponent);
+
+	const APawn* Pawn = GetPawn<APawn>();
+	if (!Pawn)
+	{
+		return;
+	}
+
+	const APlayerController* PC = GetController<APlayerController>();
+	check(PC);
+
+	const ULyraLocalPlayer* LP = Cast<ULyraLocalPlayer>(PC->GetLocalPlayer());
+	check(LP);
+
+	UEnhancedInputLocalPlayerSubsystem* Subsystem = LP->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>();
+	check(Subsystem);
+
+	Subsystem->ClearAllMappings();
+
+	if (const ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
+	{
+		if (const ULyraPawnData* PawnData = PawnExtComp->GetPawnData<ULyraPawnData>())
+		{
+			if (const ULyraInputConfig* InputConfig = PawnData->InputConfig)
+			{
+				for (const FInputMappingContextAndPriority& Mapping : DefaultInputMappings)
+				{
+					if (UInputMappingContext* IMC = Mapping.InputMapping.LoadSynchronous())
+					{
+						if (Mapping.bRegisterWithSettings)
+						{
+							if (UEnhancedInputUserSettings* Settings = Subsystem->GetUserSettings())
+							{
+								Settings->RegisterInputMappingContext(IMC);
+							}
+							
+							FModifyContextOptions Options = {};
+							Options.bIgnoreAllPressedKeysUntilRelease = false;
+							// Actually add the config to the local player							
+							Subsystem->AddMappingContext(IMC, Mapping.Priority, Options);
+						}
+					}
+				}
+
+				// The Lyra Input Component has some additional functions to map Gameplay Tags to an Input Action.
+				// If you want this functionality but still want to change your input component class, make it a subclass
+				// of the ULyraInputComponent or modify this component accordingly.
+				ULyraInputComponent* LyraIC = Cast<ULyraInputComponent>(PlayerInputComponent);
+				if (ensureMsgf(LyraIC, TEXT("Unexpected Input Component class! The Gameplay Abilities will not be bound to their inputs. Change the input component to ULyraInputComponent or a subclass of it.")))
+				{
+					// Add the key mappings that may have been set by the player
+					LyraIC->AddInputMappings(InputConfig, Subsystem);
+
+					// This is where we actually bind and input action to a gameplay tag, which means that Gameplay Ability Blueprints will
+					// be triggered directly by these input actions Triggered events. 
+					TArray<uint32> BindHandles;
+					LyraIC->BindAbilityActions(InputConfig, this, &ThisClass::Input_AbilityInputTagPressed, &ThisClass::Input_AbilityInputTagReleased, /*out*/ BindHandles);
+
+					LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_Move, ETriggerEvent::Triggered, this, &ThisClass::Input_Move, /*bLogIfNotFound=*/ false);
+					LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_Look_Mouse, ETriggerEvent::Triggered, this, &ThisClass::Input_LookMouse, /*bLogIfNotFound=*/ false);
+					LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_Look_Stick, ETriggerEvent::Triggered, this, &ThisClass::Input_LookStick, /*bLogIfNotFound=*/ false);
+					LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_Crouch, ETriggerEvent::Triggered, this, &ThisClass::Input_Crouch, /*bLogIfNotFound=*/ false);
+					LyraIC->BindNativeAction(InputConfig, LyraGameplayTags::InputTag_AutoRun, ETriggerEvent::Triggered, this, &ThisClass::Input_AutoRun, /*bLogIfNotFound=*/ false);
+				}
+			}
+		}
+	}
+
+	if (ensure(!bReadyToBindInputs))
+	{
+		bReadyToBindInputs = true;
+	}
+ 
+	UGameFrameworkComponentManager::SendGameFrameworkComponentExtensionEvent(const_cast<APlayerController*>(PC), NAME_BindInputsNow);
+	UGameFrameworkComponentManager::SendGameFrameworkComponentExtensionEvent(const_cast<APawn*>(Pawn), NAME_BindInputsNow);
+}
+
+void ULyraHeroComponent::AddAdditionalInputConfig(const ULyraInputConfig* InputConfig)
+{
+	TArray<uint32> BindHandles;
+
+	const APawn* Pawn = GetPawn<APawn>();
+	if (!Pawn)
+	{
+		return;
+	}
+	
+	const APlayerController* PC = GetController<APlayerController>();
+	check(PC);
+
+	const ULocalPlayer* LP = PC->GetLocalPlayer();
+	check(LP);
+
+	UEnhancedInputLocalPlayerSubsystem* Subsystem = LP->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>();
+	check(Subsystem);
+
+	if (const ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
+	{
+		ULyraInputComponent* LyraIC = Pawn->FindComponentByClass<ULyraInputComponent>();
+		if (ensureMsgf(LyraIC, TEXT("Unexpected Input Component class! The Gameplay Abilities will not be bound to their inputs. Change the input component to ULyraInputComponent or a subclass of it.")))
+		{
+			LyraIC->BindAbilityActions(InputConfig, this, &ThisClass::Input_AbilityInputTagPressed, &ThisClass::Input_AbilityInputTagReleased, /*out*/ BindHandles);
+		}
+	}
+}
+
+void ULyraHeroComponent::RemoveAdditionalInputConfig(const ULyraInputConfig* InputConfig)
+{
+	//@TODO: Implement me!
+}
+
+bool ULyraHeroComponent::IsReadyToBindInputs() const
+{
+	return bReadyToBindInputs;
+}
+
+void ULyraHeroComponent::Input_AbilityInputTagPressed(FGameplayTag InputTag)
+{
+	if (const APawn* Pawn = GetPawn<APawn>())
+	{
+		if (const ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
+		{
+			if (ULyraAbilitySystemComponent* LyraASC = PawnExtComp->GetLyraAbilitySystemComponent())
+			{
+				LyraASC->AbilityInputTagPressed(InputTag);
+			}
+		}	
+	}
+}
+
+void ULyraHeroComponent::Input_AbilityInputTagReleased(FGameplayTag InputTag)
+{
+	const APawn* Pawn = GetPawn<APawn>();
+	if (!Pawn)
+	{
+		return;
+	}
+
+	if (const ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
+	{
+		if (ULyraAbilitySystemComponent* LyraASC = PawnExtComp->GetLyraAbilitySystemComponent())
+		{
+			LyraASC->AbilityInputTagReleased(InputTag);
+		}
+	}
+}
+
+void ULyraHeroComponent::Input_Move(const FInputActionValue& InputActionValue)
+{
+	APawn* Pawn = GetPawn<APawn>();
+	AController* Controller = Pawn ? Pawn->GetController() : nullptr;
+
+	// If the player has attempted to move again then cancel auto running
+	if (ALyraPlayerController* LyraController = Cast<ALyraPlayerController>(Controller))
+	{
+		LyraController->SetIsAutoRunning(false);
+	}
+	
+	if (Controller)
+	{
+		const FVector2D Value = InputActionValue.Get<FVector2D>();
+		const FRotator MovementRotation(0.0f, Controller->GetControlRotation().Yaw, 0.0f);
+
+		if (Value.X != 0.0f)
+		{
+			const FVector MovementDirection = MovementRotation.RotateVector(FVector::RightVector);
+			Pawn->AddMovementInput(MovementDirection, Value.X);
+		}
+
+		if (Value.Y != 0.0f)
+		{
+			const FVector MovementDirection = MovementRotation.RotateVector(FVector::ForwardVector);
+			Pawn->AddMovementInput(MovementDirection, Value.Y);
+		}
+	}
+}
+
+void ULyraHeroComponent::Input_LookMouse(const FInputActionValue& InputActionValue)
+{
+	APawn* Pawn = GetPawn<APawn>();
+
+	if (!Pawn)
+	{
+		return;
+	}
+	
+	const FVector2D Value = InputActionValue.Get<FVector2D>();
+
+	if (Value.X != 0.0f)
+	{
+		Pawn->AddControllerYawInput(Value.X);
+	}
+
+	if (Value.Y != 0.0f)
+	{
+		Pawn->AddControllerPitchInput(Value.Y);
+	}
+}
+
+void ULyraHeroComponent::Input_LookStick(const FInputActionValue& InputActionValue)
+{
+	APawn* Pawn = GetPawn<APawn>();
+
+	if (!Pawn)
+	{
+		return;
+	}
+	
+	const FVector2D Value = InputActionValue.Get<FVector2D>();
+
+	const UWorld* World = GetWorld();
+	check(World);
+
+	if (Value.X != 0.0f)
+	{
+		Pawn->AddControllerYawInput(Value.X * LyraHero::LookYawRate * World->GetDeltaSeconds());
+	}
+
+	if (Value.Y != 0.0f)
+	{
+		Pawn->AddControllerPitchInput(Value.Y * LyraHero::LookPitchRate * World->GetDeltaSeconds());
+	}
+}
+
+void ULyraHeroComponent::Input_Crouch(const FInputActionValue& InputActionValue)
+{
+	if (ALyraCharacter* Character = GetPawn<ALyraCharacter>())
+	{
+		Character->ToggleCrouch();
+	}
+}
+
+void ULyraHeroComponent::Input_AutoRun(const FInputActionValue& InputActionValue)
+{
+	if (APawn* Pawn = GetPawn<APawn>())
+	{
+		if (ALyraPlayerController* Controller = Cast<ALyraPlayerController>(Pawn->GetController()))
+		{
+			// Toggle auto running
+			Controller->SetIsAutoRunning(!Controller->GetIsAutoRunning());
+		}	
+	}
+}
+
+TSubclassOf<ULyraCameraMode> ULyraHeroComponent::DetermineCameraMode() const
+{
+	if (AbilityCameraMode)
+	{
+		return AbilityCameraMode;
+	}
+
+	const APawn* Pawn = GetPawn<APawn>();
+	if (!Pawn)
+	{
+		return nullptr;
+	}
+
+	if (ULyraPawnExtensionComponent* PawnExtComp = ULyraPawnExtensionComponent::FindPawnExtensionComponent(Pawn))
+	{
+		if (const ULyraPawnData* PawnData = PawnExtComp->GetPawnData<ULyraPawnData>())
+		{
+			return PawnData->DefaultCameraMode;
+		}
+	}
+
+	return nullptr;
+}
+
+void ULyraHeroComponent::SetAbilityCameraMode(TSubclassOf<ULyraCameraMode> CameraMode, const FGameplayAbilitySpecHandle& OwningSpecHandle)
+{
+	if (CameraMode)
+	{
+		AbilityCameraMode = CameraMode;
+		AbilityCameraModeOwningSpecHandle = OwningSpecHandle;
+	}
+}
+
+void ULyraHeroComponent::ClearAbilityCameraMode(const FGameplayAbilitySpecHandle& OwningSpecHandle)
+{
+	if (AbilityCameraModeOwningSpecHandle == OwningSpecHandle)
+	{
+		AbilityCameraMode = nullptr;
+		AbilityCameraModeOwningSpecHandle = FGameplayAbilitySpecHandle();
+	}
+}
+

LyraStarterGame/Source/LyraGame/Character/LyraHeroComponent.h

@@ -0,0 +1,108 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "Components/GameFrameworkInitStateInterface.h"
+#include "Components/PawnComponent.h"
+#include "GameFeatures/GameFeatureAction_AddInputContextMapping.h"
+#include "GameplayAbilitySpecHandle.h"
+#include "LyraHeroComponent.generated.h"
+
+#define UE_API LYRAGAME_API
+
+namespace EEndPlayReason { enum Type : int; }
+struct FLoadedMappableConfigPair;
+struct FMappableConfigPair;
+
+class UGameFrameworkComponentManager;
+class UInputComponent;
+class ULyraCameraMode;
+class ULyraInputConfig;
+class UObject;
+struct FActorInitStateChangedParams;
+struct FFrame;
+struct FGameplayTag;
+struct FInputActionValue;
+
+/**
+ * Component that sets up input and camera handling for player controlled pawns (or bots that simulate players).
+ * This depends on a PawnExtensionComponent to coordinate initialization.
+ */
+UCLASS(MinimalAPI, Blueprintable, Meta=(BlueprintSpawnableComponent))
+class ULyraHeroComponent : public UPawnComponent, public IGameFrameworkInitStateInterface
+{
+	GENERATED_BODY()
+
+public:
+
+	UE_API ULyraHeroComponent(const FObjectInitializer& ObjectInitializer);
+
+	/** Returns the hero component if one exists on the specified actor. */
+	UFUNCTION(BlueprintPure, Category = "Lyra|Hero")
+	static ULyraHeroComponent* FindHeroComponent(const AActor* Actor) { return (Actor ? Actor->FindComponentByClass<ULyraHeroComponent>() : nullptr); }
+
+	/** Overrides the camera from an active gameplay ability */
+	UE_API void SetAbilityCameraMode(TSubclassOf<ULyraCameraMode> CameraMode, const FGameplayAbilitySpecHandle& OwningSpecHandle);
+
+	/** Clears the camera override if it is set */
+	UE_API void ClearAbilityCameraMode(const FGameplayAbilitySpecHandle& OwningSpecHandle);
+
+	/** Adds mode-specific input config */
+	UE_API void AddAdditionalInputConfig(const ULyraInputConfig* InputConfig);
+
+	/** Removes a mode-specific input config if it has been added */
+	UE_API void RemoveAdditionalInputConfig(const ULyraInputConfig* InputConfig);
+
+	/** True if this is controlled by a real player and has progressed far enough in initialization where additional input bindings can be added */
+	UE_API bool IsReadyToBindInputs() const;
+	
+	/** The name of the extension event sent via UGameFrameworkComponentManager when ability inputs are ready to bind */
+	static UE_API const FName NAME_BindInputsNow;
+
+	/** The name of this component-implemented feature */
+	static UE_API const FName NAME_ActorFeatureName;
+
+	//~ Begin IGameFrameworkInitStateInterface interface
+	virtual FName GetFeatureName() const override { return NAME_ActorFeatureName; }
+	UE_API virtual bool CanChangeInitState(UGameFrameworkComponentManager* Manager, FGameplayTag CurrentState, FGameplayTag DesiredState) const override;
+	UE_API virtual void HandleChangeInitState(UGameFrameworkComponentManager* Manager, FGameplayTag CurrentState, FGameplayTag DesiredState) override;
+	UE_API virtual void OnActorInitStateChanged(const FActorInitStateChangedParams& Params) override;
+	UE_API virtual void CheckDefaultInitialization() override;
+	//~ End IGameFrameworkInitStateInterface interface
+
+protected:
+
+	UE_API virtual void OnRegister() override;
+	UE_API virtual void BeginPlay() override;
+	UE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+
+	UE_API virtual void InitializePlayerInput(UInputComponent* PlayerInputComponent);
+
+	UE_API void Input_AbilityInputTagPressed(FGameplayTag InputTag);
+	UE_API void Input_AbilityInputTagReleased(FGameplayTag InputTag);
+
+	UE_API void Input_Move(const FInputActionValue& InputActionValue);
+	UE_API void Input_LookMouse(const FInputActionValue& InputActionValue);
+	UE_API void Input_LookStick(const FInputActionValue& InputActionValue);
+	UE_API void Input_Crouch(const FInputActionValue& InputActionValue);
+	UE_API void Input_AutoRun(const FInputActionValue& InputActionValue);
+
+	UE_API TSubclassOf<ULyraCameraMode> DetermineCameraMode() const;
+
+protected:
+	
+	UPROPERTY(EditAnywhere)
+	TArray<FInputMappingContextAndPriority> DefaultInputMappings;
+	
+	/** Camera mode set by an ability. */
+	UPROPERTY()
+	TSubclassOf<ULyraCameraMode> AbilityCameraMode;
+
+	/** Spec handle for the last ability to set a camera mode. */
+	FGameplayAbilitySpecHandle AbilityCameraModeOwningSpecHandle;
+
+	/** True when player input bindings have been applied, will never be true for non - players */
+	bool bReadyToBindInputs;
+};
+
+#undef UE_API

LyraStarterGame/Source/LyraGame/Character/LyraPawn.cpp

@@ -0,0 +1,112 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "LyraPawn.h"
+
+#include "GameFramework/Controller.h"
+#include "LyraLogChannels.h"
+#include "Net/UnrealNetwork.h"
+#include "UObject/ScriptInterface.h"
+
+#include UE_INLINE_GENERATED_CPP_BY_NAME(LyraPawn)
+
+class FLifetimeProperty;
+class UObject;
+
+ALyraPawn::ALyraPawn(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+void ALyraPawn::GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const
+{
+	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
+
+	DOREPLIFETIME(ThisClass, MyTeamID);
+}
+
+void ALyraPawn::PreInitializeComponents()
+{
+	Super::PreInitializeComponents();
+}
+
+void ALyraPawn::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	Super::EndPlay(EndPlayReason);
+}
+
+void ALyraPawn::PossessedBy(AController* NewController)
+{
+	const FGenericTeamId OldTeamID = MyTeamID;
+
+	Super::PossessedBy(NewController);
+
+	// Grab the current team ID and listen for future changes
+	if (ILyraTeamAgentInterface* ControllerAsTeamProvider = Cast<ILyraTeamAgentInterface>(NewController))
+	{
+		MyTeamID = ControllerAsTeamProvider->GetGenericTeamId();
+		ControllerAsTeamProvider->GetTeamChangedDelegateChecked().AddDynamic(this, &ThisClass::OnControllerChangedTeam);
+	}
+	ConditionalBroadcastTeamChanged(this, OldTeamID, MyTeamID);
+}
+
+void ALyraPawn::UnPossessed()
+{
+	AController* const OldController = GetController();
+
+	// Stop listening for changes from the old controller
+	const FGenericTeamId OldTeamID = MyTeamID;
+	if (ILyraTeamAgentInterface* ControllerAsTeamProvider = Cast<ILyraTeamAgentInterface>(OldController))
+	{
+		ControllerAsTeamProvider->GetTeamChangedDelegateChecked().RemoveAll(this);
+	}
+
+	Super::UnPossessed();
+
+	// Determine what the new team ID should be afterwards
+	MyTeamID = DetermineNewTeamAfterPossessionEnds(OldTeamID);
+	ConditionalBroadcastTeamChanged(this, OldTeamID, MyTeamID);
+}
+
+void ALyraPawn::SetGenericTeamId(const FGenericTeamId& NewTeamID)
+{
+	if (GetController() == nullptr)
+	{
+		if (HasAuthority())
+		{
+			const FGenericTeamId OldTeamID = MyTeamID;
+			MyTeamID = NewTeamID;
+			ConditionalBroadcastTeamChanged(this, OldTeamID, MyTeamID);
+		}
+		else
+		{
+			UE_LOG(LogLyraTeams, Error, TEXT("You can't set the team ID on a pawn (%s) except on the authority"), *GetPathNameSafe(this));
+		}
+	}
+	else
+	{
+		UE_LOG(LogLyraTeams, Error, TEXT("You can't set the team ID on a possessed pawn (%s); it's driven by the associated controller"), *GetPathNameSafe(this));
+	}
+}
+
+FGenericTeamId ALyraPawn::GetGenericTeamId() const
+{
+	return MyTeamID;
+}
+
+FOnLyraTeamIndexChangedDelegate* ALyraPawn::GetOnTeamIndexChangedDelegate()
+{
+	return &OnTeamChangedDelegate;
+}
+
+void ALyraPawn::OnControllerChangedTeam(UObject* TeamAgent, int32 OldTeam, int32 NewTeam)
+{
+	const FGenericTeamId MyOldTeamID = MyTeamID;
+	MyTeamID = IntegerToGenericTeamId(NewTeam);
+	ConditionalBroadcastTeamChanged(this, MyOldTeamID, MyTeamID);
+}
+
+void ALyraPawn::OnRep_MyTeamID(FGenericTeamId OldTeamID)
+{
+	ConditionalBroadcastTeamChanged(this, OldTeamID, MyTeamID);
+}
+

LyraStarterGame/Source/LyraGame/Character/LyraPawn.h

@@ -0,0 +1,68 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "ModularPawn.h"
+#include "Teams/LyraTeamAgentInterface.h"
+
+#include "LyraPawn.generated.h"
+
+#define UE_API LYRAGAME_API
+
+class AController;
+class UObject;
+struct FFrame;
+
+/**
+ * ALyraPawn
+ */
+UCLASS(MinimalAPI)
+class ALyraPawn : public AModularPawn, public ILyraTeamAgentInterface
+{
+	GENERATED_BODY()
+
+public:
+
+	UE_API ALyraPawn(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
+
+	//~AActor interface
+	UE_API virtual void PreInitializeComponents() override;
+	UE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+	//~End of AActor interface
+
+	//~APawn interface
+	UE_API virtual void PossessedBy(AController* NewController) override;
+	UE_API virtual void UnPossessed() override;
+	//~End of APawn interface
+
+	//~ILyraTeamAgentInterface interface
+	UE_API virtual void SetGenericTeamId(const FGenericTeamId& NewTeamID) override;
+	UE_API virtual FGenericTeamId GetGenericTeamId() const override;
+	UE_API virtual FOnLyraTeamIndexChangedDelegate* GetOnTeamIndexChangedDelegate() override;
+	//~End of ILyraTeamAgentInterface interface
+
+protected:
+	// Called to determine what happens to the team ID when possession ends
+	virtual FGenericTeamId DetermineNewTeamAfterPossessionEnds(FGenericTeamId OldTeamID) const
+	{
+		// This could be changed to return, e.g., OldTeamID if you want to keep it assigned afterwards, or return an ID for some neutral faction, or etc...
+		return FGenericTeamId::NoTeam;
+	}
+
+private:
+	UFUNCTION()
+	UE_API void OnControllerChangedTeam(UObject* TeamAgent, int32 OldTeam, int32 NewTeam);
+
+private:
+	UPROPERTY(ReplicatedUsing = OnRep_MyTeamID)
+	FGenericTeamId MyTeamID;
+
+	UPROPERTY()
+	FOnLyraTeamIndexChangedDelegate OnTeamChangedDelegate;
+
+private:
+	UFUNCTION()
+	UE_API void OnRep_MyTeamID(FGenericTeamId OldTeamID);
+};
+
+#undef UE_API