Save Often

Source/Aura/Private/AbilitySystem/AuraAbilitySystemLibrary.cpp

@@ -67,3 +67,19 @@ void UAuraAbilitySystemLibrary::InitializeDefaultAttributes(const UObject* World
 	const FGameplayEffectSpecHandle VitalAttributesSpecHandle = ASC->MakeOutgoingSpec(CharacterClassInfo->VitalAttributes, Level, VitalAttributesContextHandle);
 	ASC->ApplyGameplayEffectSpecToSelf(*VitalAttributesSpecHandle.Data.Get());
 }
+
+void UAuraAbilitySystemLibrary::GiveStartupAbilities(const UObject* WorldContextObject, UAbilitySystemComponent* ASC)
+{
+	
+	AAuraGameMode* AuraGameMode = Cast<AAuraGameMode>(UGameplayStatics::GetGameMode(WorldContextObject));
+	if (AuraGameMode == nullptr) return;
+
+	UCharacterClassInfo* CharacterClassInfo = AuraGameMode->CharacterClassInfo;
+	for (TSubclassOf<UGameplayAbility> AbilityClass : CharacterClassInfo->CommonAbilities)
+	{
+		FGameplayAbilitySpec AbilitySpec = FGameplayAbilitySpec(AbilityClass, 1);
+		ASC->GiveAbility(AbilitySpec);
+	}
+
+	
+}

Source/Aura/Private/AbilitySystem/AuraAttributeSet.cpp

@@ -144,7 +144,12 @@ void UAuraAttributeSet::PostGameplayEffectExecute(const FGameplayEffectModCallba
 		{
 			const float NewHealth = GetHealth()-LocalIncomingDamage;
 			SetHealth(FMath::Clamp(NewHealth, 0, GetMaxHealth()));
-			const bool bFatal = NewHealth <= 0;
+			const bool bFatal = NewHealth <= 0.f;
+
+			if (bFatal)
+			{
+				
+			}
 		}
 	}
 }

Source/Aura/Private/AbilitySystem/AuraProjectileSpell.cpp

@@ -2,7 +2,6 @@
 
 
 #include "AbilitySystem/AuraProjectileSpell.h"
-
 #include "AbilitySystemBlueprintLibrary.h"
 #include "AbilitySystemComponent.h"
 #include "AuraGameplayTags.h"
@@ -45,7 +44,10 @@ void UAuraProjectileSpell::SpawnProjectile(const FVector ProjectileTargetLocatio
 		const FGameplayEffectSpecHandle SpecHandle = SourceASC->MakeOutgoingSpec(DamageEffectClass, GetAbilityLevel(), SourceASC->MakeEffectContext());
 
 		const FAuraGameplayTags GameplayTags = FAuraGameplayTags::Get();
-		UAbilitySystemBlueprintLibrary::AssignTagSetByCallerMagnitude(SpecHandle, GameplayTags.Damage, Damage);
+		const float ScaledDamage = Damage.GetValueAtLevel(GetAbilityLevel());
+		//const float ScaledDamage = Damage.GetValueAtLevel(1);
+		
+		UAbilitySystemBlueprintLibrary::AssignTagSetByCallerMagnitude(SpecHandle, GameplayTags.Damage, ScaledDamage);
 		
 		Projectile->DamageEffectSpecHandle = SpecHandle;
 		Projectile->FinishSpawning(SpawnTransform);

Source/Aura/Private/AbilitySystem/Data/CharacterClassInfo.cpp

@@ -0,0 +1,9 @@
+// Copyright Echo Devgroup
+
+
+#include "AbilitySystem/Data/CharacterClassInfo.h"
+
+FCharacterClassDefaultInfo UCharacterClassInfo::GetClassDefaultInfo(ECharacterClass CharacterClass)
+{
+	return CharacterClassInformation.FindChecked(CharacterClass);
+}

Source/Aura/Private/AbilitySystem/GameplayAbility/AuraDamageAbility.cpp

@@ -0,0 +1,4 @@
+// Copyright Echo Devgroup
+
+
+#include "AbilitySystem/GameplayAbility/AuraDamageAbility.h"

Source/Aura/Private/AuraGameplayTags.cpp

@@ -50,8 +50,8 @@ void FAuraGameplayTags::InitializeNativeGameplayTags()
 	GameplayTags.Input_InputTag_Shift	= UGameplayTagsManager::Get().AddNativeGameplayTag(FName("Input.InputTag.Shift"),	FString("Input Tag - Input Shift"));
 
 	
-	GameplayTags.Damage	= UGameplayTagsManager::Get().AddNativeGameplayTag(FName("Damage"),	FString("Setting Damage"));
-	GameplayTags.Combat_HitReact	= UGameplayTagsManager::Get().AddNativeGameplayTag(FName("Combat.HitReact"),	FString("Hit react to damage"));
+	GameplayTags.Damage					= UGameplayTagsManager::Get().AddNativeGameplayTag(FName("Damage"),					FString("Setting Damage"));
+	GameplayTags.Combat_HitReact		= UGameplayTagsManager::Get().AddNativeGameplayTag(FName("Combat.HitReact"),		FString("Hit react to damage"));
 
 }
  

Source/Aura/Private/Character/AuraCharacterBase.cpp

@@ -25,6 +25,11 @@ UAbilitySystemComponent* AAuraCharacterBase::GetAbilitySystemComponent() const
 	return AbilitySystemComponent;
 }
 
+UAnimMontage* AAuraCharacterBase::GetHitReactMontage_Implementation()
+{
+	return HitReactMontage;
+}
+
 void AAuraCharacterBase::BeginPlay()
 {
 	Super::BeginPlay();

Source/Aura/Private/Character/AuraEnemy.cpp

@@ -2,11 +2,13 @@
 
 #include "Character/AuraEnemy.h"
 
+#include "AuraGameplayTags.h"
 #include "AbilitySystem/AuraAbilitySystemComponent.h"
 #include "AbilitySystem/AuraAbilitySystemLibrary.h"
 #include "AbilitySystem/AuraAttributeSet.h"
 #include "Aura/Aura.h"
 #include "Components/WidgetComponent.h"
+#include "GameFramework/CharacterMovementComponent.h"
 #include "UI/Widget/AuraUserWidget.h"
 
 AAuraEnemy::AAuraEnemy()
@@ -16,7 +18,6 @@ AAuraEnemy::AAuraEnemy()
 	AbilitySystemComponent->SetIsReplicated(true);
 	AbilitySystemComponent->SetReplicationMode(EGameplayEffectReplicationMode::Minimal);
 	AttributeSet = CreateDefaultSubobject<UAuraAttributeSet>("AttributeSet");
-
 	HealthBar = CreateDefaultSubobject<UWidgetComponent>("HealthBar");
 	HealthBar->SetupAttachment(GetRootComponent());
 }
@@ -27,28 +28,6 @@ void AAuraEnemy::HighlightActor()
 	GetMesh()->SetCustomDepthStencilValue(CUSTOM_DEPTH_RED);
 	Weapon->SetRenderCustomDepth(true);
 	Weapon->SetCustomDepthStencilValue(CUSTOM_DEPTH_RED);
-
-	if (UAuraUserWidget* AuraUserWidget = Cast<UAuraUserWidget>(HealthBar->GetUserWidgetObject()))
-	{
-		AuraUserWidget->SetWidgetController(this);
-	}
-
-	if (const UAuraAttributeSet* AuraAS = Cast<UAuraAttributeSet>(AttributeSet))
-	{
-		AbilitySystemComponent->GetGameplayAttributeValueChangeDelegate(AuraAS->GetHealthAttribute()).AddLambda(
-			[this](const FOnAttributeChangeData& Data){ OnHealthChanged.Broadcast(Data.NewValue); }
-		);
-		AbilitySystemComponent->GetGameplayAttributeValueChangeDelegate(AuraAS->GetMaxHealthAttribute()).AddLambda(
-			[this](const FOnAttributeChangeData& Data)
-			{
-				OnMaxHealthChanged.Broadcast(Data.NewValue);
-			}
-		);
-		
-		OnHealthChanged.Broadcast(AuraAS->GetHealth());
-		OnMaxHealthChanged.Broadcast(AuraAS->GetMaxHealth());
-	}
-	
 }
 
 void AAuraEnemy::UnHighlightActor()
@@ -65,7 +44,39 @@ int32 AAuraEnemy::GetPlayerLevel()
 void AAuraEnemy::BeginPlay()
 {
 	Super::BeginPlay();
+	GetCharacterMovement()->MaxWalkSpeed = BaseWalkSpeed;
 	InitAbilityActorInfo();
+	UAuraAbilitySystemLibrary::GiveStartupAbilities(this, AbilitySystemComponent);
+	
+	if (UAuraUserWidget* AuraUserWidget = Cast<UAuraUserWidget>(HealthBar->GetUserWidgetObject()))
+	{
+		AuraUserWidget->SetWidgetController(this);
+	}
+
+	if (const UAuraAttributeSet* AuraAS = Cast<UAuraAttributeSet>(AttributeSet))
+	{
+		AbilitySystemComponent->GetGameplayAttributeValueChangeDelegate(AuraAS->GetHealthAttribute()).AddLambda(
+			[this](const FOnAttributeChangeData& Data){ OnHealthChanged.Broadcast(Data.NewValue); }
+		);
+		AbilitySystemComponent->GetGameplayAttributeValueChangeDelegate(AuraAS->GetMaxHealthAttribute()).AddLambda(
+			[this](const FOnAttributeChangeData& Data)
+			{
+				OnMaxHealthChanged.Broadcast(Data.NewValue);
+			}
+		);
+		AbilitySystemComponent->RegisterGameplayTagEvent(FAuraGameplayTags::Get().Combat_HitReact, EGameplayTagEventType::NewOrRemoved).AddUObject(
+			this,
+			&AAuraEnemy::HitReactTagChanged
+		);
+		OnHealthChanged.Broadcast(AuraAS->GetHealth());
+		OnMaxHealthChanged.Broadcast(AuraAS->GetMaxHealth());
+	}
+}
+
+void AAuraEnemy::HitReactTagChanged(const FGameplayTag CallbackTag, int32 NewCount)
+{
+	bHitReacting = NewCount > 0;
+	GetCharacterMovement()->MaxWalkSpeed = bHitReacting ? 0.f : BaseWalkSpeed;
 }
 
 void AAuraEnemy::InitAbilityActorInfo()

Source/Aura/Private/Player/AuraPlayerController.cpp

@@ -46,7 +46,6 @@ void AAuraPlayerController::AutoRun()
 
 void AAuraPlayerController::CursorTrace()
 {
-
 	GetHitResultUnderCursor(ECC_Visibility, false, CursorHit);
 	if (!CursorHit.bBlockingHit) return;
 	AActor* HitActor = CursorHit.GetActor();
@@ -54,6 +53,7 @@ void AAuraPlayerController::CursorTrace()
 
 	LastActor = ThisActor;
 	ThisActor = Enemy;
+	
 	if (LastActor != ThisActor)
 	{
 		if (LastActor) LastActor->UnHighlightActor();

Source/Aura/Public/AbilitySystem/AuraAbilitySystemLibrary.h

@@ -30,5 +30,8 @@ public:
 
 	UFUNCTION(BlueprintCallable, Category="AuraAbilitySystem|Attributes")
 	static void InitializeDefaultAttributes(const UObject* WorldContextObject, ECharacterClass CharacterClass, float Level, UAbilitySystemComponent* ASC);
+
+	UFUNCTION(BlueprintCallable, Category="AuraAbilitySystem|Attributes")
+	static void GiveStartupAbilities(const UObject* WorldContextObject, UAbilitySystemComponent* ASC);
 	
 };

Source/Aura/Public/AbilitySystem/Data/AttributeInfo.h

@@ -37,4 +37,4 @@ public:
 	
 	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
 	TArray<FAuraAttributeInfo> AttributeInformation;
-};
+};

Source/Aura/Public/AbilitySystem/Data/CharacterClassInfo.h

@@ -0,0 +1,49 @@
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/DataAsset.h"
+#include "CharacterClassInfo.generated.h"
+
+
+class UGameplayEffect;
+
+UENUM(BlueprintType)
+enum class ECharacterClass : uint8
+{
+	Elementalist,
+	Warrior,
+	Ranger
+};
+
+USTRUCT(BlueprintType)
+struct FCharacterClassDefaultInfo
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditDefaultsOnly, Category = "Class Defaults")
+	TSubclassOf<UGameplayEffect> PrimaryAttributes;
+};
+
+/**
+ * 
+ */
+UCLASS()
+class AURA_API UCharacterClassInfo : public UDataAsset
+{
+	GENERATED_BODY()
+public:
+	UPROPERTY(EditDefaultsOnly, Category = "Character Class Defaults")
+	TMap<ECharacterClass, FCharacterClassDefaultInfo> CharacterClassInformation;
+
+	UPROPERTY(EditDefaultsOnly, Category = "Common Class Defaults")
+	TSubclassOf<UGameplayEffect> SecondaryAttributes;
+
+	UPROPERTY(EditDefaultsOnly, Category = "Common Class Defaults")
+	TSubclassOf<UGameplayEffect> VitalAttributes;
+
+	UPROPERTY(EditDefaultsOnly, Category = "Common Class Defaults")
+	TArray<TSubclassOf<UGameplayEffect>> CommonAbilities;
+
+	FCharacterClassDefaultInfo GetClassDefaultInfo(ECharacterClass CharacterClass);
+};

Source/Aura/Public/AbilitySystem/GameplayAbility/AuraDamageAbility.h

@@ -0,0 +1,17 @@
+// Copyright Echo Devgroup
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "AbilitySystem/GameplayAbility/AuraGameplayAbility.h"
+#include "AuraDamageAbility.generated.h"
+
+/**
+ * 
+ */
+UCLASS()
+class AURA_API UAuraDamageAbility : public UAuraGameplayAbility
+{
+	GENERATED_BODY()
+	
+};

Source/Aura/Public/AbilitySystem/GameplayAbility/AuraGameplayAbility.h

@@ -20,8 +20,5 @@ public:
 	FGameplayTag StartupInputTag;
 	
 	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability Params")
-	float Damage;
-	
-	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability Params")
-	float Level;
+	FScalableFloat Damage;
 };

Source/Aura/Public/Character/AuraCharacterBase.h

@@ -10,6 +10,12 @@
 #include "AuraCharacterBase.generated.h"
 
 
+class UAbilitySystemComponent;
+class UAttributeSet;
+class UGameplayEffect;
+class UGameplayAbility;
+class UAnimMontage;
+
 UCLASS(Abstract)
 class AURA_API AAuraCharacterBase : public ACharacter, public IAbilitySystemInterface, public ICombatInterface
 {
@@ -20,6 +26,7 @@ public:
 	virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override;
 	UAttributeSet* GetAttributeSet() const { return AttributeSet; }
 
+	virtual UAnimMontage* GetHitReactMontage_Implementation() override;
 protected:
 	virtual void BeginPlay() override;
 
@@ -57,4 +64,7 @@ private:
 	UPROPERTY(EditAnywhere, Category="Abilities")
 	TArray<TSubclassOf<UGameplayAbility>> StartupAbilities;
 	
+	UPROPERTY(EditAnywhere, Category = "Combat")
+	TObjectPtr<UAnimMontage> HitReactMontage;
+	
 };

Source/Aura/Public/Character/AuraEnemy.h

@@ -32,7 +32,14 @@ public:
 	FOnAttributeChangedSignature OnHealthChanged;
 	UPROPERTY(BlueprintAssignable)
 	FOnAttributeChangedSignature OnMaxHealthChanged;
+	void HitReactTagChanged(const FGameplayTag CallbackTag, int32 NewCount);
 
+	UPROPERTY(BlueprintReadOnly, Category = "Combat")
+	bool bHitReacting = false;
+
+	UPROPERTY(BlueprintReadOnly, Category = "Combat")
+	float BaseWalkSpeed = 250.f;
+	
 protected:
 	virtual void BeginPlay() override;
 	virtual void InitAbilityActorInfo() override;

Source/Aura/Public/Interact/CombatInterface.h

@@ -28,4 +28,7 @@ public:
 	
 	UFUNCTION(BlueprintImplementableEvent, BlueprintCallable)
 	void UpdateFacingTarget(const FVector& TargetLocation);
+	
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
+	UAnimMontage* GetHitReactMontage();
 };