pcy35549
/
D1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

main
PCYPC\pcy35 2023-08-18 21:25:29 +09:00
parent 4f847d25fd
commit 7838da179b
13 changed files with 354 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Config/DefaultEngine.ini
View File

@ -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

60
Source/D1/Actor/BaseWeapon.cpp
View File

@ -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(ECharacterAction::HeavyAttack, 15.f);
ActionStatCost.Add(ECharacterAction::ChargedAttack, 20.f);
ActionStatCost.Add(ECharacterAction::FallingAttack, 10.f);
ActionStatCost.Add(ECharacterAction::SprintAttack, 10.f);
ActionStatCost.Add(ECharacterAction::Dodge, 20.f);
ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_LightAttack, 10.f);
ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack, 15.f);
ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack, 20.f);
ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack, 10.f);
ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack, 10.f);
ActionStatCost.Add(FCombatGameplayTags::Get().Character_Action_Dodge, 20.f);
ActionDamageMultiplier.Add(ECharacterAction::LightAttack, 1.f);
ActionDamageMultiplier.Add(ECharacterAction::HeavyAttack, 1.4f);
ActionDamageMultiplier.Add(ECharacterAction::ChargedAttack, 1.5f);
ActionDamageMultiplier.Add(ECharacterAction::FallingAttack, 1.2f);
ActionDamageMultiplier.Add(ECharacterAction::SprintAttack, 1.2f);
ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_LightAttack, 1.f);
ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack, 1.4f);
ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack, 1.5f);
ActionDamageMultiplier.Add(FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack, 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)
{
case ECharacterAction::Nothing:
break;
case ECharacterAction::GeneralAction:
break;
case ECharacterAction::LightAttack:
if (FCombatGameplayTags::Get().Character_Action_Attack_LightAttack == characterAction)
outputArr = LightAttackMontage;
break;
case ECharacterAction::HeavyAttack:
else if (FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack == characterAction)
outputArr = HeavyAttackMontage;
break;
case ECharacterAction::ChargedAttack:
else if (FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack == characterAction)
outputArr = ChargedAttackMontage;
break;
case ECharacterAction::FallingAttack:
else if (FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack == characterAction)
outputArr = FallingAttackMontage;
break;
case ECharacterAction::SprintAttack:
else if (FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack == characterAction)
outputArr = SprintAttackMontage;
break;
case ECharacterAction::Dodge:
else if (FCombatGameplayTags::Get().Character_Action_Dodge == characterAction)
outputArr = DodgeMontage;
break;
case ECharacterAction::EnterCombat:
else if (FCombatGameplayTags::Get().Character_Action_EnterCombat == characterAction)
outputArr.Add(EnterCombat);
break;
case ECharacterAction::ExitCombat:
else if (FCombatGameplayTags::Get().Character_Action_ExitCombat == characterAction)
outputArr.Add(ExitCombat);
break;
default:
break;
}
return outputArr;
}

6
Source/D1/Actor/BaseWeapon.h
View File

@ -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;
};

271
Source/D1/CombatCharacter.cpp
View File

@ -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)
StateManagerComponent->SetCurrentState(ECharacterState::Nothing);
if (StateManagerComponent->GetCurrentState() == FCombatGameplayTags::Get().Character_State_Attacking)
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)
{
case ECharacterState::Nothing:
break;
case ECharacterState::Attacking:
break;
case ECharacterState::Dodging:
break;
case ECharacterState::GeneralActionState:
break;
case ECharacterState::Dead:
break;
case ECharacterState::Disable:
break;
default:
break;
}
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)
{/*None*/}
else if (FCombatGameplayTags::Get().Character_State_Disable == CharState)
{/*None*/}
}
void ACombatCharacter::CharacterActionBegin(ECharacterAction CharAction)
void ACombatCharacter::CharacterActionBegin(FGameplayTag CharAction)
{
switch (CharAction)
{
case ECharacterAction::Nothing:
break;
case ECharacterAction::GeneralAction:
break;
case ECharacterAction::LightAttack:
break;
case ECharacterAction::HeavyAttack:
break;
case ECharacterAction::ChargedAttack:
break;
case ECharacterAction::FallingAttack:
break;
case ECharacterAction::SprintAttack:
break;
case ECharacterAction::Dodge:
break;
case ECharacterAction::EnterCombat:
break;
case ECharacterAction::ExitCombat:
break;
default:
break;
}
if(FGameplayTag::EmptyTag == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_GeneralAction == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Dodge == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_EnterCombat == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_ExitCombat == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_LightAttack == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack == CharAction)
{/*None*/ }
}
void ACombatCharacter::CharacterActionEnd(ECharacterAction CharAction)
void ACombatCharacter::CharacterActionEnd(FGameplayTag CharAction)
{
switch (CharAction)
{
case ECharacterAction::Nothing:
break;
case ECharacterAction::GeneralAction:
break;
case ECharacterAction::LightAttack:
break;
case ECharacterAction::HeavyAttack:
break;
case ECharacterAction::ChargedAttack:
break;
case ECharacterAction::FallingAttack:
break;
case ECharacterAction::SprintAttack:
break;
case ECharacterAction::Dodge:
break;
case ECharacterAction::EnterCombat:
break;
case ECharacterAction::ExitCombat:
break;
default:
break;
}
if(FGameplayTag::EmptyTag == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_GeneralAction == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Dodge == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_EnterCombat == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_ExitCombat == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_LightAttack == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_HeavyAttack == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_ChargedAttack == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_FallingAttack == CharAction)
{/*None*/ }
else if(FCombatGameplayTags::Get().Character_Action_Attack_SprintAttack == CharAction)
{/*None*/ }
}
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->SetCurrentAction(ECharacterAction::Dodge);
StateManagerComponent->SetCurrentState(FCombatGameplayTags::Get().Character_State_Dodging);
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)
@ -709,15 +692,15 @@ void ACombatCharacter::PerformDeath()
bool ACombatCharacter::CanPerformToggleCombat()
{
bool ReturnValue = true;
FGameplayTagContainer inputContainer;
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Attacking);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dodging);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Disable);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_GeneralActionState);
TArray<ECharacterState> inputArr = {
ECharacterState::Attacking,
ECharacterState::Dodging,
ECharacterState::Dead,
ECharacterState::Disable,
ECharacterState::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,
ECharacterState::Dodging,
ECharacterState::Dead,
ECharacterState::Disable,
ECharacterState::GeneralActionState
};
ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
FGameplayTagContainer inputContainer;
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Attacking);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dodging);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Disable);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_GeneralActionState);
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,
ECharacterState::Dead,
ECharacterState::Disable,
ECharacterState::GeneralActionState
};
ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
FGameplayTagContainer inputContainer;
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dodging);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Disable);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_GeneralActionState);
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,
ECharacterState::Dead,
ECharacterState::Disable,
ECharacterState::GeneralActionState
};
ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
FGameplayTagContainer inputContainer;
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dodging);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Disable);
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_GeneralActionState);
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,
};
ReturnValue &= !StateManagerComponent->IsCurrentStateEqualToAny(inputArr);
FGameplayTagContainer inputContainer;
inputContainer.AddTag(FCombatGameplayTags::Get().Character_State_Dead);
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;
}

14
Source/D1/CombatCharacter.h
View File

@ -116,10 +116,10 @@ protected:
void StopSprint(const FInputActionValue& Value);
private://Delegate
void CharacterStateBegin(ECharacterState CharState);
void CharacterStateEnd(ECharacterState CharState);
void CharacterActionBegin(ECharacterAction CharAction);
void CharacterActionEnd(ECharacterAction CharAction);
void CharacterStateBegin(FGameplayTag CharState);
void CharacterStateEnd(FGameplayTag CharState);
void CharacterActionBegin(FGameplayTag 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;

18
Source/D1/Components/StateManagerComponent.cpp
View File

@ -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);
}

50
Source/D1/Components/StateManagerComponent.h
View File

@ -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)
enum class ECharacterAction : uint8
{
Nothing UMETA(DisplayName = "Nothing"),
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);
DECLARE_MULTICAST_DELEGATE_OneParam(FStateBegin, FGameplayTag);
DECLARE_MULTICAST_DELEGATE_OneParam(FStateEnd, FGameplayTag);
DECLARE_MULTICAST_DELEGATE_OneParam(FActionBegin, FGameplayTag);
DECLARE_MULTICAST_DELEGATE_OneParam(FActionEnd, FGameplayTag);
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);
ECharacterState GetCurrentState();
void SetCurrentState(FGameplayTag NewState);
FGameplayTag GetCurrentState();
void ResetState();
bool IsCurrentStateEqualToAny(TArray<ECharacterState> StatesToCheck);
bool IsCurrentStateEqualToAny(FGameplayTagContainer StatesToCheck);
void SetCurrentAction(ECharacterAction NewAction);
ECharacterAction GetCurrentAction();
bool IsCurrentActionEqualToAny(TArray<ECharacterAction> ActionToCheck);
void SetCurrentAction(FGameplayTag NewAction);
FGameplayTag GetCurrentAction();
bool IsCurrentActionEqualToAny(FGameplayTagContainer ActionToCheck);
public: //Delegate
FStateBegin OnStateBegin;
@ -71,6 +47,6 @@ public: //Delegate
FActionEnd OnActionEnd;
private:
ECharacterState CurrentState;
ECharacterAction CurrentAction;
FGameplayTag CurrentState;
FGameplayTag CurrentAction;
};

2
Source/D1/Components/StatsComponent.cpp
View File

@ -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)

5
Source/D1/D1.Build.cs
View File

@ -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" });
}

22
Source/D1/Definitions/CombatAssetManager.cpp 100644
View File

@ -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();
}

22
Source/D1/Definitions/CombatAssetManager.h 100644
View File

@ -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;
};

86
Source/D1/Definitions/CombatGameplayTags.cpp 100644
View File

@ -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")
);
}

34
Source/D1/Definitions/CombatGameplayTags.h 100644
View File

@ -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;
};