[박치영] State 및 Action Enum을 GameplayTag로 변경

Config/DefaultEngine.ini

@@ -53,6 +53,7 @@ AppliedDefaultGraphicsPerformance=Maximum
 +ActiveGameNameRedirects=(OldGameName="/Script/TP_ThirdPerson",NewGameName="/Script/D1")
 +ActiveClassRedirects=(OldClassName="TP_ThirdPersonGameMode",NewClassName="D1GameMode")
 +ActiveClassRedirects=(OldClassName="TP_ThirdPersonCharacter",NewClassName="D1Character")
+AssetManagerClassName=/Script/D1.CombatAssetManager
 
 [/Script/AndroidFileServerEditor.AndroidFileServerRuntimeSettings]
 bEnablePlugin=True

Source/D1/Actor/BaseWeapon.cpp

@@ -6,6 +6,7 @@
 #include "GameFramework/Character.h"
 #include "Components/CollisionComponent.h"
 #include "Interface/CombatInterface.h"
+#include "Definitions/CombatGameplayTags.h"
 #include "Kismet/GameplayStatics.h"
 
 ABaseWeapon::ABaseWeapon()
@@ -21,18 +22,18 @@ ABaseWeapon::ABaseWeapon()
 	CollisionComponent->SetCollisionObjectTypes(InputCollisionObjectTypes);
 	CollisionComponent->SetDrawDebugType(EDrawDebugTrace::None);
 
-	ActionStatCost.Add(ECharacterAction::LightAttack, 10.f);
+	ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_LightAttack, 10.f);
-	ActionStatCost.Add(ECharacterAction::HeavyAttack, 15.f);
+	ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack, 15.f);
-	ActionStatCost.Add(ECharacterAction::ChargedAttack, 20.f);
+	ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack, 20.f);
-	ActionStatCost.Add(ECharacterAction::FallingAttack, 10.f);
+	ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack, 10.f);
-	ActionStatCost.Add(ECharacterAction::SprintAttack, 10.f);
+	ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack, 10.f);
-	ActionStatCost.Add(ECharacterAction::Dodge, 20.f);
+	ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Dodge, 20.f);
 
-	ActionDamageMultiplier.Add(ECharacterAction::LightAttack, 1.f);
+	ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_LightAttack, 1.f);
-	ActionDamageMultiplier.Add(ECharacterAction::HeavyAttack, 1.4f);
+	ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack, 1.4f);
-	ActionDamageMultiplier.Add(ECharacterAction::ChargedAttack, 1.5f);
+	ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack, 1.5f);
-	ActionDamageMultiplier.Add(ECharacterAction::FallingAttack, 1.2f);
+	ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack, 1.2f);
-	ActionDamageMultiplier.Add(ECharacterAction::SprintAttack, 1.2f);
+	ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack, 1.2f);
 }
 
 void ABaseWeapon::OnEquipped()
@@ -96,41 +97,26 @@ float ABaseWeapon::GetDamage()
 	return outDamage;
 }
 
-TArray<UAnimMontage*> ABaseWeapon::GetActionMontage(ECharacterAction characterAction)
+TArray<UAnimMontage*> ABaseWeapon::GetActionMontage(FGameplayTag characterAction)
 {
 	TArray<UAnimMontage*> outputArr;
-	switch (characterAction)
+
-	{
+	if (FCombatGameplayTags::Get().Character_Action_Attack_LightAttack == characterAction)
-	case ECharacterAction::Nothing:
-		break;
-	case ECharacterAction::GeneralAction:
-		break;
-	case ECharacterAction::LightAttack:
 		outputArr = LightAttackMontage;
-		break;
+	else if (FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack == characterAction)
-	case ECharacterAction::HeavyAttack:
 		outputArr = HeavyAttackMontage;
-		break;
+	else if (FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack == characterAction)
-	case ECharacterAction::ChargedAttack:
 		outputArr = ChargedAttackMontage;
-		break;
+	else if (FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack == characterAction)
-	case ECharacterAction::FallingAttack:
 		outputArr = FallingAttackMontage;
-		break;
+	else if (FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack == characterAction)
-	case ECharacterAction::SprintAttack:
 		outputArr = SprintAttackMontage;
-		break;
+	else if (FCombatGameplayTags::Get().Character_Action_Dodge == characterAction)
-	case ECharacterAction::Dodge:
 		outputArr = DodgeMontage;
-		break;
+	else if (FCombatGameplayTags::Get().Character_Action_EnterCombat == characterAction)
-	case ECharacterAction::EnterCombat:
 		outputArr.Add(EnterCombat);
-		break;
+	else if (FCombatGameplayTags::Get().Character_Action_ExitCombat == characterAction)
-	case ECharacterAction::ExitCombat:
 		outputArr.Add(ExitCombat);
-		break;
+
-	default:
-		break;
-	}
 	return outputArr;
 }

Source/D1/Actor/BaseWeapon.h

@@ -35,7 +35,7 @@ public:
 	float GetStatCostForAction();
 	float GetDamage();
 public:
-	TArray<UAnimMontage*> GetActionMontage(ECharacterAction characterAction);
+	TArray<UAnimMontage*> GetActionMontage(FGameplayTag characterAction);
 
 protected:
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Initialization")
@@ -70,8 +70,8 @@ protected:
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stat")
 	float Damage;
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stat")
-	TMap<ECharacterAction, float> ActionStatCost;
+	TMap<FGameplayTag, float> ActionStatCost;
 
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Stat")
-	TMap<ECharacterAction, float> ActionDamageMultiplier;
+	TMap<FGameplayTag, float> ActionDamageMultiplier;
 };

Source/D1/CombatCharacter.cpp

@@ -13,6 +13,7 @@
 #include "Actor/BaseWeapon.h"
 #include "Components/CombatComponent.h"
 #include "Components/StatsComponent.h"
+#include "Definitions/CombatGameplayTags.h"
 #include "Engine/DamageEvents.h"
 #include "Kismet/KismetSystemLibrary.h"
 #include "Kismet/KismetMathLibrary.h"
@@ -130,7 +131,7 @@ float ACombatCharacter::TakeDamage(float Damage, FDamageEvent const& DamageEvent
 		
 		if (CanReceiveHitReaction())
 		{
-			StateManagerComponent->SetCurrentState(ECharacterState::Disable);
+			StateManagerComponent->SetCurrentState(FCombatGameplayTags::Get().Character_State_Disable);
 			
 			//Play Animation
 			PlayAnimMontage(HitMontage);
@@ -144,8 +145,8 @@ void ACombatCharacter::ContinueAttack_Implementation()
 	if (CombatComponent->GetIsAttackSaved())
 	{
 		CombatComponent->SetIsAttackSaved(false);
-		if (StateManagerComponent->GetCurrentState() == ECharacterState::Attacking)
+		if (StateManagerComponent->GetCurrentState() == FCombatGameplayTags::Get().Character_State_Attacking)
-			StateManagerComponent->SetCurrentState(ECharacterState::Nothing);
+			StateManagerComponent->SetCurrentState(FGameplayTag::EmptyTag);
 		AttackEvent();
 	}
 }
@@ -159,7 +160,7 @@ void ACombatCharacter::ResetCombat_Implementation()
 {
 	CombatComponent->ResetAttack();
 	StateManagerComponent->ResetState();
-	StateManagerComponent->SetCurrentAction(ECharacterAction::Nothing);
+	StateManagerComponent->SetCurrentAction(FGameplayTag::EmptyTag);
 }
 
 FRotator ACombatCharacter::GetDesiredRotation_Implementation()
@@ -174,7 +175,7 @@ FRotator ACombatCharacter::GetDesiredRotation_Implementation()
 bool ACombatCharacter::CanReceiveDamage_Implementation()
 {
 	bool result;
-	result = (StateManagerComponent->GetCurrentState() != ECharacterState::Dead);
+	result = (StateManagerComponent->GetCurrentState() != FCombatGameplayTags::Get().Character_State_Dead);
 	return result;
 }
 
@@ -219,6 +220,7 @@ void ACombatCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerIn
 		//Sprint
 		EnhancedInputComponent->BindAction(SprintAction, ETriggerEvent::Started, this, &ACombatCharacter::StartSprint);
 		EnhancedInputComponent->BindAction(SprintAction, ETriggerEvent::Completed, this, &ACombatCharacter::StopSprint);
+		
 	}
 }
 
@@ -300,7 +302,7 @@ void ACombatCharacter::LightAttack(const FInputActionValue& Value)
 		return;
 	IsHeavyAttack = false;
 
-	if (StateManagerComponent->GetCurrentState() == ECharacterState::Attacking)
+	if (StateManagerComponent->GetCurrentState() == FCombatGameplayTags::Get().Character_State_Attacking)
 		CombatComponent->SetIsAttackSaved(true);
 	else
 		AttackEvent();
@@ -315,7 +317,7 @@ void ACombatCharacter::LightChargeAttack(const FInputActionInstance& Instance)
 	{
 		if (CanPerformAttack())
 		{
-			PerformAttack(ECharacterAction::ChargedAttack, CombatComponent->GetAttackCount());
+			PerformAttack(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack, CombatComponent->GetAttackCount());
 			ABaseWeapon* pBaseWeapon = CombatComponent->GetMainWeapon();
 			if (IsValid(pBaseWeapon))
 			{
@@ -331,7 +333,7 @@ void ACombatCharacter::HeavyAttack(const FInputActionValue& Value)
 	if (bAttackCharged)
 		return;
 	IsHeavyAttack = true;
-	if (StateManagerComponent->GetCurrentState() == ECharacterState::Attacking)
+	if (StateManagerComponent->GetCurrentState() == FCombatGameplayTags::Get().Character_State_Attacking)
 		CombatComponent->SetIsAttackSaved(true);
 	else
 		AttackEvent();
@@ -376,105 +378,86 @@ void ACombatCharacter::StopSprint(const FInputActionValue& Value)
 	DisableSprint();
 }
 
-void ACombatCharacter::CharacterStateBegin(ECharacterState CharState)
+void ACombatCharacter::CharacterStateBegin(FGameplayTag CharState)
 {
-	switch (CharState)
+	if (FGameplayTag::EmptyTag == CharState)
+	{/*None*/}
+	else if (FCombatGameplayTags::Get().Character_State_Attacking == CharState)
+	{/*None*/}
+	else if (FCombatGameplayTags::Get().Character_State_Dodging == CharState)
+	{/*None*/}
+	else if (FCombatGameplayTags::Get().Character_State_GeneralActionState == CharState)
+	{/*None*/}
+	else if (FCombatGameplayTags::Get().Character_State_Dead == CharState)
 	{
-	case ECharacterState::Nothing:
-		break;
-	case ECharacterState::Attacking:
-		break;
-	case ECharacterState::Dodging:
-		break;
-	case ECharacterState::GeneralActionState:
-		break;
-	case ECharacterState::Dead:
 		PerformDeath();
-		break;
-	case ECharacterState::Disable:
-		break;
-	default:
-		break;
 	}
+	else if (FCombatGameplayTags::Get().Character_State_Disable == CharState)
+	{/*None*/}
 }
 
-void ACombatCharacter::CharacterStateEnd(ECharacterState CharState)
+void ACombatCharacter::CharacterStateEnd(FGameplayTag CharState)
 {
-	switch (CharState)
+	if (FGameplayTag::EmptyTag == CharState)
-	{
+	{/*None*/}
-	case ECharacterState::Nothing:
+	else if (FCombatGameplayTags::Get().Character_State_Attacking == CharState)
-		break;
+	{/*None*/}
-	case ECharacterState::Attacking:
+	else if (FCombatGameplayTags::Get().Character_State_Dodging == CharState)
-		break;
+	{/*None*/}
-	case ECharacterState::Dodging:
+	else if (FCombatGameplayTags::Get().Character_State_GeneralActionState == CharState)
-		break;
+	{/*None*/}
-	case ECharacterState::GeneralActionState:
+	else if (FCombatGameplayTags::Get().Character_State_Dead == CharState)
-		break;
+	{/*None*/}
-	case ECharacterState::Dead:
+	else if (FCombatGameplayTags::Get().Character_State_Disable == CharState)
-		break;
+	{/*None*/}
-	case ECharacterState::Disable:
-		break;
-	default:
-		break;
-	}
 }
 
-void ACombatCharacter::CharacterActionBegin(ECharacterAction CharAction)
+void ACombatCharacter::CharacterActionBegin(FGameplayTag CharAction)
 {
-	switch (CharAction)
+	if(FGameplayTag::EmptyTag == CharAction)
-	{
+	{/*None*/ }
-	case ECharacterAction::Nothing:
+	else if(FCombatGameplayTags::Get().Character_Action_GeneralAction == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::GeneralAction:
+	else if(FCombatGameplayTags::Get().Character_Action_Dodge == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::LightAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_EnterCombat == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::HeavyAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_ExitCombat == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::ChargedAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_LightAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::FallingAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::SprintAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::Dodge:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::EnterCombat:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::ExitCombat:
-		break;
-	default:
-		break;
-	}
 }
 
-void ACombatCharacter::CharacterActionEnd(ECharacterAction CharAction)
+void ACombatCharacter::CharacterActionEnd(FGameplayTag CharAction)
 {
-	switch (CharAction)
+	if(FGameplayTag::EmptyTag == CharAction)
-	{
+	{/*None*/ }
-	case ECharacterAction::Nothing:
+	else if(FCombatGameplayTags::Get().Character_Action_GeneralAction == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::GeneralAction:
+	else if(FCombatGameplayTags::Get().Character_Action_Dodge == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::LightAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_EnterCombat == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::HeavyAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_ExitCombat == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::ChargedAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_LightAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::FallingAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::SprintAttack:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::Dodge:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::EnterCombat:
+	else if(FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack == CharAction)
-		break;
+	{/*None*/ }
-	case ECharacterAction::ExitCombat:
-		break;
-	default:
-		break;
-	}
 }
 
 void ACombatCharacter::CharacterCurrentStatValueUpdated(EStats statType, float value)
@@ -482,7 +465,7 @@ void ACombatCharacter::CharacterCurrentStatValueUpdated(EStats statType, float v
 	if (!(statType == EStats::Health) || value > 0.f)
 		return;
 
-	StateManagerComponent->SetCurrentState(ECharacterState::Dead);
+	StateManagerComponent->SetCurrentState(FCombatGameplayTags::Get().Character_State_Dead);
 }
 
 void ACombatCharacter::ToggleCombatEvent()
@@ -495,9 +478,9 @@ void ACombatCharacter::ToggleCombatEvent()
 		return;
 
 	if (!CombatComponent->GetCombatEnabled())
-		PerformAction(ECharacterState::GeneralActionState, ECharacterAction::EnterCombat, 0);
+		PerformAction(FCombatGameplayTags::Get().Character_State_GeneralActionState, FCombatGameplayTags::Get().Character_Action_EnterCombat, 0);
 	else
-		PerformAction(ECharacterState::GeneralActionState, ECharacterAction::ExitCombat, 0);
+		PerformAction(FCombatGameplayTags::Get().Character_State_GeneralActionState, FCombatGameplayTags::Get().Character_Action_ExitCombat, 0);
 }
 
 void ACombatCharacter::AttackEvent()
@@ -596,7 +579,7 @@ void ACombatCharacter::SprintStaminaCost()
 	}
 }
 
-void ACombatCharacter::PerformAttack(ECharacterAction attackType, int32 attackIndex)
+void ACombatCharacter::PerformAttack(FGameplayTag attackType, int32 attackIndex)
 {
 	ABaseWeapon* CurrentWeapon = CombatComponent->GetMainWeapon();
 	if (!CurrentWeapon)
@@ -619,7 +602,7 @@ void ACombatCharacter::PerformAttack(ECharacterAction attackType, int32 attackIn
 	}
 	else
 	{
-		StateManagerComponent->SetCurrentState(ECharacterState::Attacking);
+		StateManagerComponent->SetCurrentState(FCombatGameplayTags::Get().Character_State_Attacking);
 		StateManagerComponent->SetCurrentAction(attackType);
 
 		PlayAnimMontage(attackMontage);
@@ -639,7 +622,7 @@ void ACombatCharacter::PerformDodge()
 	if (!CurrentWeapon)
 		return;
 	int32 montageIndex = 0;
-	TArray<UAnimMontage*> montages = CurrentWeapon->GetActionMontage(ECharacterAction::Dodge);
+	TArray<UAnimMontage*> montages = CurrentWeapon->GetActionMontage(FCombatGameplayTags::Get().Character_Action_Dodge);
 	if (montages.Num() <= montageIndex)
 		montageIndex = 0;
 	if (!montages.IsValidIndex(montageIndex))
@@ -648,8 +631,8 @@ void ACombatCharacter::PerformDodge()
 	UAnimMontage* dodgeMontage = montages[montageIndex];
 	if (IsValid(dodgeMontage))
 	{
-		StateManagerComponent->SetCurrentState(ECharacterState::Dodging);
+		StateManagerComponent->SetCurrentState(FCombatGameplayTags::Get().Character_State_Dodging);
-		StateManagerComponent->SetCurrentAction(ECharacterAction::Dodge);
+		StateManagerComponent->SetCurrentAction(FCombatGameplayTags::Get().Character_Action_Dodge);
 		PlayAnimMontage(dodgeMontage);
 	}
 	else
@@ -659,7 +642,7 @@ void ACombatCharacter::PerformDodge()
 	}
 }
 
-bool ACombatCharacter::PerformAction(ECharacterState characterState, ECharacterAction characterAction, int32 montageIndex)
+bool ACombatCharacter::PerformAction(FGameplayTag characterState, FGameplayTag characterAction, int32 montageIndex)
 {
 	ABaseWeapon* CurrentWeapon = CombatComponent->GetMainWeapon();
 	if (!CurrentWeapon)
@@ -710,14 +693,14 @@ bool ACombatCharacter::CanPerformToggleCombat()
 {
 	bool ReturnValue = true;
 
-	TArray<ECharacterState> inputArr = { 
+	FGameplayTagContainer inputContainer;
-		ECharacterState::Attacking,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Attacking);
-		ECharacterState::Dodging,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dodging);
-		ECharacterState::Dead,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
-		ECharacterState::Disable, 
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Disable);
-		ECharacterState::GeneralActionState 
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_GeneralActionState);
-	};
+	
-	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
+	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputContainer);
 	ReturnValue &= !GetCharacterMovement()->IsFalling();
 	return ReturnValue;
 }
@@ -725,14 +708,15 @@ bool ACombatCharacter::CanPerformToggleCombat()
 bool ACombatCharacter::CanPerformAttack()
 {
 	bool ReturnValue = true;
-	TArray<ECharacterState> inputArr = {
+
-		ECharacterState::Attacking,
+	FGameplayTagContainer inputContainer;
-		ECharacterState::Dodging,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Attacking);
-		ECharacterState::Dead,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dodging);
-		ECharacterState::Disable,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
-		ECharacterState::GeneralActionState
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Disable);
-	};
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_GeneralActionState);
-	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
+
+	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputContainer);
 	ReturnValue &= (StatsComponent->GetCurrentStatValue(EStats::Stamina) >= 10.f);
 
 	return ReturnValue;
@@ -741,13 +725,14 @@ bool ACombatCharacter::CanPerformAttack()
 bool ACombatCharacter::CanPerformDodge()
 {
 	bool ReturnValue = true;
-	TArray<ECharacterState> inputArr = {
+
-		ECharacterState::Dodging,
+	FGameplayTagContainer inputContainer;
-		ECharacterState::Dead,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dodging);
-		ECharacterState::Disable,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
-		ECharacterState::GeneralActionState
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Disable);
-	};
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_GeneralActionState);
-	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
+
+	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputContainer);
 	ReturnValue &= !GetCharacterMovement()->IsFalling();
 	ReturnValue &= (StatsComponent->GetCurrentStatValue(EStats::Stamina) >= 10.f);
 	return ReturnValue;
@@ -756,13 +741,14 @@ bool ACombatCharacter::CanPerformDodge()
 bool ACombatCharacter::CanJumping()
 {
 	bool ReturnValue = true;
-	TArray<ECharacterState> inputArr = {
+
-		ECharacterState::Dodging,
+	FGameplayTagContainer inputContainer;
-		ECharacterState::Dead,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dodging);
-		ECharacterState::Disable,
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
-		ECharacterState::GeneralActionState
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Disable);
-	};
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_GeneralActionState);
-	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
+
+	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputContainer);
 	ReturnValue &= !GetCharacterMovement()->IsFalling();
 	return ReturnValue;
 }
@@ -770,10 +756,11 @@ bool ACombatCharacter::CanJumping()
 bool ACombatCharacter::CanReceiveHitReaction()
 {
 	bool ReturnValue = true;
-	TArray<ECharacterState> inputArr = {
+
-		ECharacterState::Dead,
+	FGameplayTagContainer inputContainer;
-	};
+	inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
-	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
+
+	ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputContainer);
 	return ReturnValue;
 }
 
@@ -782,18 +769,18 @@ bool ACombatCharacter::CanPerformSprint()
 	return (FMath::IsNearlyEqual(GetVelocity().Length(), 0.f)) == false;
 }
 
-ECharacterAction ACombatCharacter::GetDesiredAttackType()
+FGameplayTag ACombatCharacter::GetDesiredAttackType()
 {
 	if (GetCharacterMovement()->IsFalling())
-		return ECharacterAction::FallingAttack;
+		return FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack;
 
 	if (GetMovementSpeedMode() == EMovementSpeedMode::Sprinting)
-		return ECharacterAction::SprintAttack;
+		return FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack;
 
 	if (IsHeavyAttack)
-		return ECharacterAction::HeavyAttack;
+		return FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack;
 
-	return ECharacterAction::LightAttack;
+	return FCombatGameplayTags::Get().Character_Action_Attack_LightAttack;
 }
 
 

Source/D1/CombatCharacter.h

@@ -116,10 +116,10 @@ protected:
 	void StopSprint(const FInputActionValue& Value);
 	
 private://Delegate
-	void CharacterStateBegin(ECharacterState CharState);
+	void CharacterStateBegin(FGameplayTag CharState);
-	void CharacterStateEnd(ECharacterState CharState);
+	void CharacterStateEnd(FGameplayTag CharState);
-	void CharacterActionBegin(ECharacterAction CharAction);
+	void CharacterActionBegin(FGameplayTag CharAction);
-	void CharacterActionEnd(ECharacterAction CharAction);
+	void CharacterActionEnd(FGameplayTag CharAction);
 	void CharacterCurrentStatValueUpdated(EStats statType, float value);
 
 private:
@@ -134,9 +134,9 @@ private:
 	void SprintStaminaCost();
 
 private:
-	void PerformAttack(ECharacterAction attackType, int32 attackIndex);
+	void PerformAttack(FGameplayTag attackType, int32 attackIndex);
 	void PerformDodge();
-	bool PerformAction(ECharacterState characterState, ECharacterAction characterAction, int32 montageIndex);
+	bool PerformAction(FGameplayTag characterState, FGameplayTag characterAction, int32 montageIndex);
 	void PerformDeath();
 
 protected:
@@ -146,7 +146,7 @@ protected:
 	bool CanJumping();
 	bool CanReceiveHitReaction();
 	bool CanPerformSprint();
-	ECharacterAction GetDesiredAttackType();
+	FGameplayTag GetDesiredAttackType();
 public:
 	UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category="Components", meta=(AllowPrivateAccess="true"))
 	TObjectPtr<class UCombatComponent> CombatComponent;

Source/D1/Components/StateManagerComponent.cpp

@@ -32,7 +32,7 @@ void UStateManagerComponent::TickComponent(float DeltaTime, ELevelTick TickType,
 	// ...
 }
 
-void UStateManagerComponent::SetCurrentState(ECharacterState NewState)
+void UStateManagerComponent::SetCurrentState(FGameplayTag NewState)
 {
 	if (NewState != CurrentState)
 	{
@@ -42,22 +42,22 @@ void UStateManagerComponent::SetCurrentState(ECharacterState NewState)
 	}
 }
 
-ECharacterState UStateManagerComponent::GetCurrentState()
+FGameplayTag UStateManagerComponent::GetCurrentState()
 {
 	return CurrentState;
 }
 
 void UStateManagerComponent::ResetState()
 {
-	CurrentState = ECharacterState::Nothing;
+	CurrentState = FGameplayTag::EmptyTag;
 }
 
-bool UStateManagerComponent::IsCurrentStateEqualToAny(TArray<ECharacterState> StatesToCheck)
+bool UStateManagerComponent::IsCurrentStateEqualToAny(FGameplayTagContainer StatesToCheck)
 {
-	return StatesToCheck.Contains(CurrentState);
+	return StatesToCheck.HasTagExact(CurrentState);
 }
 
-void UStateManagerComponent::SetCurrentAction(ECharacterAction NewAction)
+void UStateManagerComponent::SetCurrentAction(FGameplayTag NewAction)
 {
 	if (CurrentAction != NewAction)
 	{
@@ -67,12 +67,12 @@ void UStateManagerComponent::SetCurrentAction(ECharacterAction NewAction)
 	}
 }
 
-ECharacterAction UStateManagerComponent::GetCurrentAction()
+FGameplayTag UStateManagerComponent::GetCurrentAction()
 {
 	return CurrentAction;
 }
 
-bool UStateManagerComponent::IsCurrentActionEqualToAny(TArray<ECharacterAction> ActionToCheck)
+bool UStateManagerComponent::IsCurrentActionEqualToAny(FGameplayTagContainer ActionToCheck)
 {
-	return ActionToCheck.Contains(CurrentAction);
+	return ActionToCheck.HasTagExact(CurrentAction);
 }

Source/D1/Components/StateManagerComponent.h

@@ -4,38 +4,14 @@
 
 #include "CoreMinimal.h"
 #include "Components/ActorComponent.h"
+#include "Definitions/CombatGameplayTags.h"
 #include "StateManagerComponent.generated.h"
 
-UENUM(BlueprintType)
-enum class ECharacterState : uint8
-{
-	Nothing UMETA(DisplayName = "Nothing"),
-	Attacking UMETA(DisplayName = "Attacking"),
-	Dodging UMETA(DisplayName = "Dodging"),
-	GeneralActionState UMETA(DisplayName = "GeneralActionState"),
-	Dead UMETA(DisplayName = "Dead"),
-	Disable UMETA(DisplayName = "Disable")
-};
 
-UENUM(BlueprintType)
+DECLARE_MULTICAST_DELEGATE_OneParam(FStateBegin, FGameplayTag);
-enum class ECharacterAction : uint8
+DECLARE_MULTICAST_DELEGATE_OneParam(FStateEnd, FGameplayTag);
-{
+DECLARE_MULTICAST_DELEGATE_OneParam(FActionBegin, FGameplayTag);
-	Nothing UMETA(DisplayName = "Nothing"),
+DECLARE_MULTICAST_DELEGATE_OneParam(FActionEnd, FGameplayTag);
-	GeneralAction UMETA(DisplayName = "GeneralAction"),
-	LightAttack UMETA(DisplayName = "LightAttack"),
-	HeavyAttack UMETA(DisplayName = "HeavyAttack"),
-	ChargedAttack UMETA(DisplayName = "ChargedAttack"),
-	FallingAttack UMETA(DisplayName = "FallingAttack"),
-	SprintAttack UMETA(DisplayName = "SprintAttack"),
-	Dodge UMETA(DisplayName = "Dodge"),
-	EnterCombat UMETA(DisplayName = "EnterCombat"),
-	ExitCombat UMETA(DisplayName = "ExitCombat"),
-};
-
-DECLARE_MULTICAST_DELEGATE_OneParam(FStateBegin, ECharacterState);
-DECLARE_MULTICAST_DELEGATE_OneParam(FStateEnd, ECharacterState);
-DECLARE_MULTICAST_DELEGATE_OneParam(FActionBegin, ECharacterAction);
-DECLARE_MULTICAST_DELEGATE_OneParam(FActionEnd, ECharacterAction);
 
 UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
 class D1_API UStateManagerComponent : public UActorComponent
@@ -55,14 +31,14 @@ public:
 	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
 
 public:
-	void SetCurrentState(ECharacterState NewState);
+	void SetCurrentState(FGameplayTag NewState);
-	ECharacterState GetCurrentState();
+	FGameplayTag GetCurrentState();
 	void ResetState();
-	bool IsCurrentStateEqualToAny(TArray<ECharacterState> StatesToCheck);
+	bool IsCurrentStateEqualToAny(FGameplayTagContainer StatesToCheck);
 
-	void SetCurrentAction(ECharacterAction NewAction);
+	void SetCurrentAction(FGameplayTag NewAction);
-	ECharacterAction GetCurrentAction();
+	FGameplayTag GetCurrentAction();
-	bool IsCurrentActionEqualToAny(TArray<ECharacterAction> ActionToCheck);
+	bool IsCurrentActionEqualToAny(FGameplayTagContainer ActionToCheck);
 
 public:	//Delegate
 	FStateBegin OnStateBegin;
@@ -71,6 +47,6 @@ public:	//Delegate
 	FActionEnd OnActionEnd;
 
 private:
-	ECharacterState CurrentState;
+	FGameplayTag CurrentState;
-	ECharacterAction CurrentAction;
+	FGameplayTag CurrentAction;
 };

Source/D1/Components/StatsComponent.cpp

@@ -78,7 +78,7 @@ void UStatsComponent::TakeDamageOnStat(float inDamage)
 	GEngine->AddOnScreenDebugMessage(-1, 3.f, FColor::Red, debugStr);
 
 	if (GetCurrentStatValue(EStats::Health) <= 0.f)
-		GetOwner()->GetComponentByClass<UStateManagerComponent>()->SetCurrentState(ECharacterState::Dead);
+		GetOwner()->GetComponentByClass<UStateManagerComponent>()->SetCurrentState(FCombatGameplayTags::Get().Character_State_Dead);
 }
 
 void UStatsComponent::StartRegen(EStats statType)

Source/D1/D1.Build.cs

@@ -8,7 +8,10 @@ public class D1 : ModuleRules
 	{
 		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
 
-		PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "EnhancedInput" });
+		PublicDependencyModuleNames.AddRange(new string[] { 
+			"Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", 
+			"EnhancedInput", "GameplayTags" 
+		});
 
 		PublicIncludePaths.AddRange(new string[] { "D1" });
 	}

Source/D1/Definitions/CombatAssetManager.cpp

@@ -0,0 +1,22 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "Definitions/CombatAssetManager.h"
+#include "Definitions/CombatGameplayTags.h"
+
+UCombatAssetManager& UCombatAssetManager::Get()
+{
+	check(GEngine);
+
+	UCombatAssetManager* CombatAssetManager = Cast<UCombatAssetManager>(GEngine->AssetManager);
+	return *CombatAssetManager;
+}
+
+void UCombatAssetManager::StartInitialLoading()
+{
+	Super::StartInitialLoading();
+
+	//AssetManager에서 Singleton 초기화
+	//Editor의 Engine General Settings에서 설정 변경 필요
+	FCombatGameplayTags::InitializeNativeGameplayTags();
+}

Source/D1/Definitions/CombatAssetManager.h

@@ -0,0 +1,22 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/AssetManager.h"
+#include "CombatAssetManager.generated.h"
+
+/**
+ * 
+ */
+UCLASS()
+class D1_API UCombatAssetManager : public UAssetManager
+{
+	GENERATED_BODY()
+	
+public:
+	static UCombatAssetManager& Get();
+
+protected:
+	virtual void StartInitialLoading() override;
+};

Source/D1/Definitions/CombatGameplayTags.cpp

@@ -0,0 +1,86 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "Definitions/CombatGameplayTags.h"
+#include "GameplayTagsManager.h"
+
+FCombatGameplayTags FCombatGameplayTags::GameplayTags;
+
+void FCombatGameplayTags::InitializeNativeGameplayTags()
+{
+	/**
+	 * State
+	 */
+	GameplayTags.Character_State_Attacking = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.State.Attacking"),
+		FString("State Attacking")
+	);
+
+	GameplayTags.Character_State_Dead = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.State.Dead"),
+		FString("State Dead")
+	);
+
+	GameplayTags.Character_State_Disable = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.State.Disable"),
+		FString("State Disable")
+	);
+
+	GameplayTags.Character_State_Dodging = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.State.Dodging"),
+		FString("State Dodging")
+	);
+
+	GameplayTags.Character_State_GeneralActionState = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.State.GeneralActionState"),
+		FString("State GeneralActionState")
+	);
+
+	/**
+	 * Action
+	 */
+	GameplayTags.Character_Action_Dodge = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.Dodge"),
+		FString("Action Dodge")
+	);
+
+	GameplayTags.Character_Action_EnterCombat = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.EnterCombat"),
+		FString("Action EnterCombat")
+	);
+
+	GameplayTags.Character_Action_ExitCombat = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.ExitCombat"),
+		FString("Action ExitCombat")
+	);
+
+	GameplayTags.Character_Action_GeneralAction = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.GeneralAction"),
+		FString("Action GeneralAction")
+	);
+
+	GameplayTags.Character_Action_Attack_ChargedAttack = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.Attack.ChargedAttack"),
+		FString("Action Attack ChargedAttack")
+	);
+
+	GameplayTags.Character_Action_Attack_FallingAttack = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.Attack.FallingAttack"),
+		FString("Action Attack FallingAttack")
+	);
+
+	GameplayTags.Character_Action_Attack_HeavyAttack = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.Attack.HeavyAttack"),
+		FString("Action Attack HeavyAttack")
+	);
+
+	GameplayTags.Character_Action_Attack_LightAttack = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.Attack.LightAttack"),
+		FString("Action Attack LightAttack")
+	);
+
+	GameplayTags.Character_Action_Attack_SprintAttack = UGameplayTagsManager::Get().AddNativeGameplayTag(
+		FName("Character.Action.Attack.SprintAttack"),
+		FString("Action Attack SprintAttack")
+	);
+}

Source/D1/Definitions/CombatGameplayTags.h

@@ -0,0 +1,34 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameplayTagContainer.h"
+
+struct FCombatGameplayTags
+{
+public:
+	static const FCombatGameplayTags& Get() { return GameplayTags; }
+	static void InitializeNativeGameplayTags();
+
+public:
+	//State
+	FGameplayTag Character_State_Attacking;
+	FGameplayTag Character_State_Dead;
+	FGameplayTag Character_State_Disable;
+	FGameplayTag Character_State_Dodging;
+	FGameplayTag Character_State_GeneralActionState;
+
+	//Action
+	FGameplayTag Character_Action_Dodge;
+	FGameplayTag Character_Action_EnterCombat;
+	FGameplayTag Character_Action_ExitCombat;
+	FGameplayTag Character_Action_GeneralAction;
+	FGameplayTag Character_Action_Attack_ChargedAttack;
+	FGameplayTag Character_Action_Attack_FallingAttack;
+	FGameplayTag Character_Action_Attack_HeavyAttack;
+	FGameplayTag Character_Action_Attack_LightAttack;
+	FGameplayTag Character_Action_Attack_SprintAttack;
+private:
+	static FCombatGameplayTags GameplayTags;
+};