개발자 동그래

GAS_16_Death Ability 구현 및 캐릭터 사후처리

동그래님 — Sat, 10 May 2025 23:36:10 +0900

Death Ability 구현

✅ Gameplay Tag 추가

✔️ RPGGameplayTags

RPGGameplayTags.h

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */

	/** Shared Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Ability_HitReact);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Ability_Death); // Death Ability Tag 추가

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Event_MeleeHit);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Event_HitReact);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_SetByCaller_BaseDamage);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Status_Dead); // Dead Status Tag 추가

}

RPGGameplayTags.cpp

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */
	
	/** Shared Tags */
	UE_DEFINE_GAMEPLAY_TAG(Shared_Ability_HitReact, "Shared.Ability.HitReact");
	UE_DEFINE_GAMEPLAY_TAG(Shared_Ability_Death, "Shared.Ability.Death"); // Death Ability Tag 추가

	UE_DEFINE_GAMEPLAY_TAG(Shared_Event_MeleeHit, "Shared.Event.MeleeHit");
	UE_DEFINE_GAMEPLAY_TAG(Shared_Event_HitReact, "Shared.Event.HitReact");

	UE_DEFINE_GAMEPLAY_TAG(Shared_SetByCaller_BaseDamage, "Shared.SetByCaller.BaseDamage");

	UE_DEFINE_GAMEPLAY_TAG(Shared_Status_Dead, "Shared.Status.Dead"); // Dead Status Tag 추가
}

사망 관련 Gameplay Tag 추가

✅ AttributeSet에서 Dead.Status Tag 부착

✔️ RPGAttributeSet.cpp

#include "AbilitySystem/RPGAttributeSet.h"
#include "GameplayEffectExtension.h"
#include "RPGFunctionLibrary.h"
#include "RPGGameplayTags.h"

#include "WarriorDebugHelper.h"

URPGAttributeSet::URPGAttributeSet()
{
	InitCurrentHealth(1.0f);
	InitMaxHealth(1.0f);
	InitCurrentRage(1.0f);
	InitMaxRage(1.0f);
	InitAttackPower(1.0f);
	InitDefensePower(1.0f);
}

void URPGAttributeSet::PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data)
{
	// GE 실행 결과로 Modifier가 적용된 Attribute가 CurrentHealth라면 해당 로직 실행
	if (Data.EvaluatedData.Attribute == GetCurrentHealthAttribute())
	{
		const float NewCurrentHealth = FMath::Clamp(GetCurrentHealth(), 0.0f, GetMaxHealth());

		SetCurrentHealth(NewCurrentHealth);
	}

	if (Data.EvaluatedData.Attribute == GetCurrentRageAttribute())
	{
		const float NewCurrentRage = FMath::Clamp(GetCurrentRage(), 0.0f, GetMaxRage());

		SetCurrentRage(NewCurrentRage);
	}

	if (Data.EvaluatedData.Attribute == GetDamageTakenAttribute())
	{
		const float OldHealth = GetCurrentHealth();
		const float DamageDone = GetDamageTaken();

		const float NewCurrentHealth = FMath::Clamp(OldHealth - DamageDone, 0.0f, GetMaxHealth());

		SetCurrentHealth(NewCurrentHealth);

		const FString DebugString = FString::Printf(
			TEXT("Old Health %f, Damage Done: %f, NewCurrentHealth: %f"),
			OldHealth,
			DamageDone,
			NewCurrentHealth
		);

		Debug::Print(DebugString, FColor::Green);

		// TODO::사망 처리
		if (NewCurrentHealth == 0.0f)
		{
			URPGFunctionLibrary::AddGameplayTagToActorIfNone(Data.Target.GetAvatarActor(), RPGGameplayTags::Shared_Status_Dead);
		}
	}
}

이전에 체력 및 적용할 데미지 Attribute 값에 Modifier가 적용되면 호출 되는 함수에서 현재 체력이 0인지 확인하고 만약 0이 된다면 사망처리 시키는 Tag를 붙혀주기로 했었다.
앞서 만든 "Shared.Status.Dead"를 체력이 0이 된 TargetActor에 붙혀주도록 한다.

✅ Enemy 사망 처리할 Ability 생성

"RPGEnemyGameplayAbility"를 상속 받는 "GA_Enemy_Death_Base" 클래스를 생성한다.
Montage 배열에서 랜덤한 사망 관련 AnimMontage를 재생하고 GameplayCue로 사망 사운드를 재생한다.

자식 클래스를 생성하고 필요한 데이터를 할당한다.
1. 사망 관련 Anim Montage 바인딩
2. 사망 사운드 Gameplay Cue 바인딩
3. 해당 Ability 활성화 시, 다른 모든 Ability 및 HitReact 취소 및 block 처리
4. Instancing Policy는 어차피 딱 한 번 사망할 것이기 때문에 기본 값
5. Trigger Tag는 "Shared.Status.Dead" 로 설정(AttributeSet C++에서 Target Actor의 체력이 0이면 해당 태그 부여)
6. Trigger Source는 ASC가 해당 Trigger Tag를 획득하면 Ability가 트리거 되는 설정인 "Owned Tag Added"로 설정

✅ Enemy StartUpData에 GA 할당

Reactive Abilities에 "GA_Guardian_Death" 할당

✅ BP Interface 클래스 생성

Death Ability 이후 Enemy 캐릭터의 Mesh를 Pause 상태로 만들고 Collision을 비활성화 하기 위해, BP Interface 클래스를 만들고 BP_EnemyBase 클래스가 이를 구현하도록 한다.

✅ BP Interface 함수 구현

"BP_EnemyCharacter_Base" 클래스에서 "BPI_EnemyDeath"를 상속 받고 해당 함수를 구현한다.

"GA_Enemy_Death_Base" 클래스에서 EndAbility Event에 Enemy캐릭터의 OnEnemyDied 인터페이스 함수를 호출해준다.

사망처리 테스트

체력이 0으로 떨어져, 사망 판정이 되면 Death Anim Montage가 나오는 것을 확인할 수 있다.
또한 BPI 함수를 Enemy Base Class에서 Mesh에 Pause를 걸고 CapsuleComponent의 Collision을 비활성화 해, 사망 애니메이션이 나온 후 정지해 있고 그 위를 캐릭터가 지나갈 수 있는 것을 확인했다.

Dissolve Material 적용

✅ Material Instance에서 Dissolve 관련 세팅

현재 Enemy의 Material Instance는 이전에 만들었던 Material Function의 기능을 추가했었다.
인스턴스를 살펴보면 "DissolveAmount"를 조절하면 점점 사라지는 것을 확인할 수 있고, "DissolveEdgeThickness"를 조절하면 사라지는 Edge 두께를 조절, "DissolveEdgeColor"에선 색상을 변경할 수 있다.

이를 통해 Death Ability가 활성화 되면 Death Montage가 재생되고 Ability가 끝난 시점에 "DissolveAmount"를 조절하여 사라지는 느낌을 연출할 수 있다.

적절한 Color를 설정한 뒤, "DissolveAmount"를 0으로 변경하고 저장한다.

✅ 사망 이후, 처리 로직 수정

DissolveTimeline 내부

TimeLine을 1초로 설정하고 PlayRate로 시간을 조절하도록 한다. TimeLine 내부의 핀을 둘 다 선택하고 숫자 '1'을 누르면 곡선 형태로 그래프가 변하게 된다.
Set Play Rate를 사용하여, TotalDisolveTime 변수의 값 시간만큼 Dissolve하여 완전히 사라지는 시간이 결정된다.
Dissolve가 끝나면 Destory 처리해준다.

✅ 무기 Material Dissolve 적용 및 Destroy 처리

무기의 Material에도 Material Function을 적용하고 Instance를 생성해주었다. 그리고 해당 Instance를 무기의 Material Slot에 할당해준다.

다시 BaseEnemy 클래스로 돌아와서, EnemyCombatComponent로 무기가 있는지 확인하고, 무기가 있다면 캐릭터와 똑같이 Dissolve 시켜준다.
Timeline이 종료되면 무기와 캐릭터를 Destroy 해주었다.

Material Dissolve 및 Destroy 테스트

캐릭터가 사망처리 되면 정해진 시간만큼 Dissolve 되며 Destroy되는 로직이 정상적으로 진행된다.

Dissolve Niagara 스폰

✅ BP Interface 함수(OnEnemyDied) 에 Niagara System 인자 추가

BPI의 OnEnemyDied 함수의 인자로 "Niagara System"을 전달하도록 하는데, 사망시 한 번만 사용되기 때문에 "Soft Object Reference"로 GA가 저장하고 있다가 해당 함수가 호출될 때, BP_EnemyBase클래스에 전달하도록 한다.

✅ GA_Enemy_Death에 NiagaraSystem 저장

사망 처리 Ability인 부모클래스에서 "On Enemy Died" 인터페이스 함수의 Niagara System 인자를 변수로 승격시킨다.

자식 클래스에서 사용하고자 하는 Niagara System을 할당한다.

✅ Dissolve Niagara 스폰 로직 구현

캐릭터 및 무기가 Dissolve되기 전에 먼저 Niagara System을 스폰한다.
함수에서 SoftlReference로 전달 받은 Niagara를 비동기 로딩한 후 Mesh에 Attach 해주었다.
현재 Enemy의 Mesh에서 "Dissolve Edge Color"로 설정된 Color 값을 Niagara "DissolveParticleColor"로 Set하여 같은 색상이 나오도록 설정하였다.

Dissolve Niagara 스폰 테스트

사망 처리시 디졸브 Niagara가 스폰되고 자동으로 사라지는 것을 확인할 수 있다.

GAS_15_GameplayCue로 타격 사운드 재생

동그래님 — Sat, 10 May 2025 21:12:30 +0900

Gameplay Cue로 사운드 재생

피격 당하는 Montage에 피격 당하는 대상의 Sound를 입히는 것은 Montage에서 해결할 수 있지만,
공격을 하는 경우에도 Montage에서 소리를 재생하면 공격이 성공하지 않았는데도 피격 사운드가 날 것이고 이는 어색하게 느껴지게 된다.
공격 모션에는 휘두르는 사운드만 들리게 하고, 타격이 성공 했을 때만 타격 피드백 사운드를 재생할 수 있도록 한다.

GameplayCue 시스템에서 사용되는 두 가지 타입 클래스

GameplayCueNotify_Static
- 정적 클래스(UObject 기반, 액터가 아님)
- 스폰되지 않고, 메모리 상에서 실행
- 한 번 실행하고 끝나는 효과에 적합(피격 사운드 재생, 임펙트 스파크 등)
- Tick이 필요 없고, 따로 씬 상에 남아있을 필요 없을 때
GameplayCueNotify_Actor
- Actor 기반 클래스
- 맵에 스폰되어 존재하며 지속적인 처리 가능(Tick, BeginPlay, Destroy 등 지원)
- 상태에 따라 시작/갱신/종료가 가능한 이펙트
- 버프/디버프, 지속시간 있는 이펙트 등

✅ Gameplay Cue BP클래스 생성

현재 타격 사운드를 재생하는 것이므로 "GamePlayCueNotify_Static"을 상속 받는 BP 클래스를 생성해준다.

생성한 클래스의 Tag를 살펴보면 아무것도 존재하지 않는다. 따라서 새롭게 GameplayCue 전용 Tag를 추가해야한다.
이번엔 에디터에서 바로 생성하도록 한다.

"GameplayCue.Sounds.MeleeHit.Axe"로 Tag 이름을 입력하고 Source를 "DefaultGameplay Tags.ini로 설정한 뒤 "Add New Tag"를 클릭한다.

"On Execute" 함수를 Override해서 다음과 같이 재정의 한다.
Target의 Location에 "Play Sound at Location" 노드를 통해 원하는 사운드를 재생할 수 있도록 한다.

✅ Gameplay Ability에 GE 실행 로직 구현

플레이어의 강공격, 약공격 Ability의 데미지 적용 함수에서 "Execute GameplayCue On Owner" 노드에 GC Tag를 변수로 승격 시키고, 자식 클래스에서 해당 변수에 Tag를 할당해준다.

✅ DefautGame.ini에 GameplayCue Path 저장

[/Script/GameplayAbilities.AbilitySystemGlobals]
bUseDebugTargetFromHud = true
GameplayCueNotifyPaths = "/Game/GameplayCues"

[/Script/EngineSettings.GeneralProjectSettings]
ProjectID=04AF6AD14CFECE9CD8FFFB86EAF63CE4
CopyrightNotice=

Gameplay Cue를 성공적으로 실행하려면 DefualtGame.ini 파일에 현재 GameplayCue가 들어있는 경로를 추가해야한다.
현재 Content폴더 아래에 바로 GameplayCues 폴더가 있고 해당 폴더 안에 "GC_Hero_AxeHit"이 있으므로 "/Game/GameplayCues" 경로를 위와 같이 저장해주고 에디터를 재시작 해준다.

Gameplay Cue로 타격 사운드 재생 테스트

GAS_14_피격 시 활성화 되는 GA_HitReact 구현

동그래님 — Sat, 10 May 2025 17:14:44 +0900

Hit React_Ability 구현

1. Gameplay Tag 설정
2. HitReact 어빌리티 생성
3. 하위 Ability 생성
4. Anim Montage 생성
5. Ability 부여

위 순서대로 Hit React Ability를 구현해보자.

✅Gameplay Tag 설정

✔️ RPGGameplayTags

RPGGameplayTags.h

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */
	
	/** Enemy Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Enemy_Ability_Melee); // 근거리 공격 추가
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Enemy_Ability_Ranged); // 원거리 공격 추가

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Enemy_Weapon);

	/** Shared Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Ability_HitReact); // HitReact 추가

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Event_MeleeHit);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Event_HitReact); // HitReact Event추가

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_SetByCaller_BaseDamage);

}

RPGGameplayTags.cpp

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */

	/** Enemy Tags */
	UE_DEFINE_GAMEPLAY_TAG(Enemy_Ability_Melee, "Enemy.Ability.Melee");
	UE_DEFINE_GAMEPLAY_TAG(Enemy_Ability_Ranged, "Enemy.Ability.Ranged");

	UE_DEFINE_GAMEPLAY_TAG(Enemy_Weapon, "Enemy.Weapon");

	/** Shared Tags */
	UE_DEFINE_GAMEPLAY_TAG(Shared_Ability_HitReact, "Shared.Ability.HitReact");

	UE_DEFINE_GAMEPLAY_TAG(Shared_Event_MeleeHit, "Shared.Event.MeleeHit");
	UE_DEFINE_GAMEPLAY_TAG(Shared_Event_HitReact, "Shared.Event.HitReact");

	UE_DEFINE_GAMEPLAY_TAG(Shared_SetByCaller_BaseDamage, "Shared.SetByCaller.BaseDamage");
}

✅ HitReact Ability 구현

"RPGEnemyGameplayAbility"를 상속 받는 GameplayAbility BP 클래스를 생성한다.

다음과 같이 로직을 구현한다. FaceAttacker의 경우 Default 값을 true로 설정한다.

앞서 구현했던 Ability와 다른 점은"Event ActivateAbilityFromEvent" 노드를 사용해야 한다는 점이다.
해당 GA는 인풋으로 발동되는 Ability가 아닌 Event로 발동되는 Ability이다. 따라서 기존에 Light Attack과 Heavy Attack 관련 Ability를 발동시키는 조건이 다르다.

앞서 구현했던 GA를 상속 받은 "GA_Guardian" 클래스를 생성하고, HitReact Montage를 할당한다.
Tag Setting으로 HitReact Ability 발동 중에는 다른 모든 Ability를 취소하고 Block 처리한다.
Instancing Policy의 경우 피격이 전투 중 수시로 발생하기 때문에 InstancedPerExecution 처럼 매번 인스턴스를 생성/파괴하게 되면 성능 낭비가 커진다.
따라서 Actor로 설정해, 최초 Ability를 부여 했을 때 한 번만 인스턴스를 생성하도록 하고 이후 추가적인 피격 시 재활성화 되는 구조가 더 적합하다.

추가적으로 Ability Trigger에 Tag 설정을 진행한다.
공격자가 공격 Ability에서 이 Tag로 Event를 전달하면, Enemy가 이 이벤트 태그를 가지고 있다면 수신할 수 있게 된다.

✅ StartUpData에 GA_HitReact 할당

Enemy의 StartUpData에 Reactive Ability 배열이 선언되어있다. 해당 배열에 방금 생성했던 "GA_Guardian_HitReact"를 할당 해준다.

✅ 플레이어 공격 Ability에서 Target에게 Event 전달

현재 플레이어의 공격 Ability 클래스인데, 그래프가 복잡해 보여 데미지를 주는 로직을 함수화 시킬 것이다.
그리고 함수 내부에서 데미지를 성공적으로 적용시켰다면, HitReact Event를 피격 대상에게 전송시킴으로써 GA_HitReact가 활성화 되도록 구현할 것이다.

위와 같이 함수화 시켜 그래프를 정리하고, 함수 명을 "HandleApplayDamage"로 변경한다.

함수 내부에서 데미지 적용이 Successful이면 "Send Gameplay Event to Actor" 노드로 피격 대상에게 HitReact Event Tag를 전달한다.

GA_HitReact 테스트

정상적으로 피격 시, HitReact Animation이 나오는 것을 확인할 수 있었고, 플레이어 위치로 회전까지 정상 작동한다.

✅ 피격 시, 머터리얼 색상 변경

Material Function을 다음과 같이 구현한 뒤 이를 이용해, HitReact시 Material 색을 잠시 바꿨다가 다시 원래대로 돌리도록 한다.

Material Instance를 생성한다.

컨텐츠 브라우저에서 스켈레탈 메시를 선택한 후 Material Instance로 돌아와 뷰포트 우측 하단에 버튼을 클릭하면 프리뷰 상태로 작업할 수 있다.

HitFxSwitch 값을 1로 올려 어떤 색으로 표시할지 정한 후, 다시 0으로 맞춰놓고 저장한다.

Enemy의 SkeletalMesh에서 방금 만든 Material Instance로 설정해준다.

Hit React Ability에서 몽타주가 있을 경우와 없을 경우 모두 스켈레탈 메시에서 머터리얼의 Scalar 값을 조절해주었다.
Parameter 이름도 Material Instance에서 복사해서 정확하게 입력해주도록 한다.
마지막으로 Ability가 종료되면 다시 0의 값을 주어 원래 상태로 되돌린다.

피격 시, 머터리얼 변화 테스트

정상적으로 HitReact Ability가 활성화 되면, Material 색상이 변하는 것을 확인할 수 있다.

타격 성공시 피드백 효과 구현

✅ 타격 성공 시, Pause 효과

* 싱글플레이 게임 전용
플레이어의 공격이 적에게 적중하면 잠깐 월드의 시간을 미세하게 정지시켜 조금 더 다이내믹한 타격 피드백을 줄 수 있다.
다만 월드의 시간을 조정하는 것이기 때문에 멀티플레이에선 해당 Ability를 사용하면 안된다.

✔️ RPGGameplayTags

RPGGameplayTags.h

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */

	/** Player Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Equip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Unequip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Attack_Light_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Attack_Heavy_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_HitPause); // 공격 성공시 Pause 태그 추가

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Weapon_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Equip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Unequip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_HitPause); // 공격 성공시 Pause Event 태그 추가
}

RPGGameplayTags.h

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */

	/** Player Tags */
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Equip_Axe, "Player.Ability.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Unequip_Axe, "Player.Ability.Unequip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Attack_Light_Axe, "Player.Ability.Attack.Light.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Attack_Heavy_Axe, "Player.Ability.Attack.Heavy.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_HitPause, "Player.Ability.HitPause"); // 공격 성공시 Pause 태그 추가


	UE_DEFINE_GAMEPLAY_TAG(Player_Weapon_Axe, "Player.Weapon.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Equip_Axe, "Player.Event.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Unequip_Axe, "Player.Event.Unequip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Event_HitPause, "Player.Event.HitPause"); // 공격 성공시 Pause Event 태그 추가
}

✔️ Gameplay Ability(HitPause) 구현

에디터에서 다음과 같이 "GA_Hero_HitPause"를 구현한다. 이로써 대상을 공격해서 피격처리가 되었을 때 다이나믹한 느낌을 만들어 낼 수 있다.

하지만 구현부를 살펴보면 월드 전체의 시간 흐름을 조절하여 효과를 Hit 피드백을 주는 것이기 때문에, 싱글플레이에서는 괜찮지만 멀티플레이 게임에서는 해당 Ability를 사용하면 안된다.
멀티플레이에선 Custom Time Dilation 기능을 만들어 자신(로컬)에게만 Dilation을 주도록 설정하는 등 다른 방법으로 구현해야한다.

✔️ Ability 할당

Hero 캐릭터의 StartUpData에 방금 만든 Ability를 할당해준다.

✔️ Hit 처리 되었을 때, 이벤트 전송해 GA_HitPause 활성화 로직

void UHeroCombatComponent::OnHitTargetActor(AActor* HitActor)
{
	if (OverlappedActors.Contains(HitActor))
	{
		return;
	}

	OverlappedActors.AddUnique(HitActor);

	FGameplayEventData Data;
	Data.Instigator = GetOwningPawn();
	Data.Target = HitActor;

	UAbilitySystemBlueprintLibrary::SendGameplayEventToActor(
		GetOwningPawn(),
		RPGGameplayTags::Shared_Event_MeleeHit,
		Data
	);
	
    // Hit Pause Ability 발동 Event 전달
	UAbilitySystemBlueprintLibrary::SendGameplayEventToActor(
		GetOwningPawn(),
		RPGGameplayTags::Player_Event_HitPause,
		FGameplayEventData()
	);
}

이전에 무기에 오버랩 되면 델리게이트 호출로 OnHitTargetActor가 호출되도록 구현했었다.
해당 함수 내부에서 HitPause 어빌리티를 실행할 Event를 전송한다.

HitPause Ability 테스트 결과

공격이 Target에 적중되지 않으면 Ability가 발생하지 않고, Target에 적중되는 순간 아주 미세하게 Pause 효과를 주어 전투의 느낌을 더 다이내믹하게 느껴진다.

CameraShake

추가적으로 HitPause에서 CameraShake를 주어 조금 더 역동적으로 전투 경험을 느끼게 할 수도 있다.

사운드 정리

HitReaction Sound를 몽타주에 넣었을 때, 적이 한번에 여러 명이 피격당하면 소리가 그 수 만큼 재생되어 정신없는 사운드가 될 것이다.
Concurrency를 생성해 한 번에 1개의 사운드만 재생되도록 설정한다면 동시에 여러 명을 타격하더라도, 하나의 HitReact 사운드를 재생시킬 수 있다.

GAS_13_피격 대상에게 GameEffect 적용

동그래님 — Fri, 9 May 2025 21:57:22 +0900

FGameEffectSpecHandle 생성

앞서 진행했던 흐름은 WeaponBase 클래스에서 Collision에 OverlapEvent가 발생하면 델리게이트로 BroadCasting을 하고,
이를 구독하고 있는 CombatComponent가 감지된 객체 정보를 Event Tag 기반으로 GameplayAbility로 Event를 송신하였고, 이를 Melee Attack 관련 Gameplay Ability에서 Event를 수신 받아 현재 피격된 대상이 누구인지까지 알게 되었다.

이제 무기 데미지, 공격 타입, 콤보 횟수 등의 요소를 저장하는 FGamaEffectSpecHandle을 생성하고 추후 최종 피해량을 계산하고 데미지를 적용시키는 것을 구현하려한다.
FGameplayEffectSpecHandle에 무기 데미지, 공격 타입, 콤보 횟수 등의 요소들을 담고 ExecutionCalculation에게 넘겨주어 계산을 하는 흐름이다.

✅ FGameplayEffectSpecHandle 반환 함수 구현

✔️ RPGGameplayTags

RPGGameplayTags.h

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */
    
	/** Shared Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Event_MeleeHit);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_SetByCaller_BaseDamage); // 기본 데미지 Tag 추가

}

RPGGameplayTags.cpp

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */

	/** Shared Tags */
	UE_DEFINE_GAMEPLAY_TAG(Shared_Event_MeleeHit, "Shared.Event.MeleeHit");

	UE_DEFINE_GAMEPLAY_TAG(Shared_SetByCaller_BaseDamage, "Shared.SetByCaller.BaseDamage");
}

외부에서 지정해주는 기본 데미지를 뜻하는 "Shared.SetByCaller.BaseDamage" Tag를 정의한다.

✔️ WarriorHeroGameplayAbility

WarriorHeroGameplayAbility.h

#include "CoreMinimal.h"
#include "AbilitySystem/Abilities/RPGGameplayAbility.h"
#include "WarriorHeroGameplayAbility.generated.h"

class AWarriorHeroCharacter;
class AWarriorHeroController;
class UHeroCombatComponent;

UCLASS()
class RPG_API UWarriorHeroGameplayAbility : public URPGGameplayAbility
{
	GENERATED_BODY()
	
public:
	UFUNCTION(BlueprintPure, Category = "RPGAbility")
	AWarriorHeroCharacter* GetHeroCharacterFromActorInfo();

	UFUNCTION(BlueprintPure, Category = "RPGAbility")
	AWarriorHeroController* GetWarriorHeroControllerFromActorInfo();

	UFUNCTION(BlueprintPure, Category = "RPGAbility")
	UHeroCombatComponent* GetHeroCombatComponentFromActorInfo();

	// GameplayEffectSpecHandle 반환 함수 추가
	UFUNCTION(BlueprintPure, Category = "RPGAbility")
	FGameplayEffectSpecHandle MakeHeroDamageEffectSpecHandle(
		TSubclassOf<UGameplayEffect> EffectClass, float InWeaponBaseDamage,
		FGameplayTag InCurrentAttackTypeTag, int32 InUsedComboCount);

private:
	TWeakObjectPtr<AWarriorHeroCharacter> CachedWarriorHeroCharacter;
	TWeakObjectPtr<AWarriorHeroController> CachedWarriorHeroController;
};

WarriorHeroGameplayAbility.cpp

#include "AbilitySystem/Abilities/WarriorHeroGameplayAbility.h"
#include "Characters/WarriorHeroCharacter.h"
#include "Controllers/WarriorHeroController.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "RPGGameplayTags.h"

/** 생략 */

FGameplayEffectSpecHandle UWarriorHeroGameplayAbility::MakeHeroDamageEffectSpecHandle(
	TSubclassOf<UGameplayEffect> EffectClass, float InWeaponBaseDamage,
	FGameplayTag InCurrentAttackTypeTag, int32 InUsedComboCount)
{
	check(EffectClass);

	// 컨텍스트 생성: 누가, 어떤 상황에서 발동 했는지
	FGameplayEffectContextHandle ContextHandle = GetRPGAbilitySystemComponentFromActorInfo()->MakeEffectContext();
	ContextHandle.SetAbility(this);
	ContextHandle.AddSourceObject(GetAvatarActorFromActorInfo());
	ContextHandle.AddInstigator(GetAvatarActorFromActorInfo(), GetAvatarActorFromActorInfo());

	// 스펙 생성: 
	FGameplayEffectSpecHandle EffectSpecHandle = GetRPGAbilitySystemComponentFromActorInfo()->MakeOutgoingSpec(
		EffectClass,
		GetAbilityLevel(),
		ContextHandle
	);

	// 무기 기본 데미지 값 전달
	EffectSpecHandle.Data->SetSetByCallerMagnitude(
		RPGGameplayTags::Shared_SetByCaller_BaseDamage,
		InWeaponBaseDamage
	);

	// 공격 유형 태그를 키로, 콤보 수를 값으로 전달
	if (InCurrentAttackTypeTag.IsValid())
	{
		EffectSpecHandle.Data->SetSetByCallerMagnitude(InCurrentAttackTypeTag, InUsedComboCount);
	}

	return EffectSpecHandle;
}

"FGameplayEffectSpecHandle"은 적용할 GameplayEffect와 그 세부정보를 담은 객체이다.
쉽게 말해 GE 클래스를 어떤 상황(Context)에, 어떤 수치(Magnitude)로 적용할지 담고 있는 객체를 반환하는 함수이다.
또한 이 객체는 GE를 실질적으로 Taget에게 적용시키려면 반드시 필요하다.

✅ Make Hero Damage Effect Spec Handle에 할당할 데이터 생성

Effect Class: ExecutionCalculation에서 실제 데미지 계산
In Weapon Base Damage: 무기 기본 공격력 → SetByCallerMagnitude()로 전달되어 데미지 계산에 사용
In Current Attack Type Tag: 강공격, 약공격 등 어떤 종류의 공격인지 ExecutionCalculation에서 분기 처리에 사용
In Used Combo Count: 콤보 수 → 공격 데미지 증폭에 반영

에디터로 돌아와서 GameplayAbility에서 C++에서 구현했던 SpecHandle을 생성하는 함수를 BP로 사용할 수 있게 되었다.
이제 각 데이터를 채워 넣기 위한 구현을 한다.

✔️ 데미지 계산 GameplayEffect 클래스 생성

"GameplayEffectExecutionCalculation"를 상속 받은 C++ 클래스를 생성해주고 "GEExecCalc_Damage"으로 명명한다.
구현은 나중에 하고 우선 클래스만 먼저 생성하도록 한다.

✔️ 플레이어와 Enemy 모두에게 적용 가능한 Damage 관련 GE 생성

데미지 계산을 처리하는 GameplayEffect를 생성하고, 앞서 생성했던 "GEExecCalc_Damage"를 Calculation Class로 설정한다.

✔️ RPGStructTypes

RPGStructTypes.h

USTRUCT(BlueprintType)
struct FRPGHeroWeaponData
{
	GENERATED_BODY()

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	TSubclassOf<UWarriorHeroLinkedAnimLayer> WeaponAnimLayerToLink;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	UInputMappingContext* WeaponInputMappingContext;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, meta = (TitleProperty = "InputTag"))
	TArray<FWarriorHeroAbilitySet> DefaultWeaponAbilities;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	FScalableFloat WeaponBaseDamage; // BaseDamage 선언
};

무기 클래스가 가지고 있는 Data 구조체에 WeaponBaseDamage를 선언한다.
FScalableFloat은 언리얼 GAS에서 데이터를 Curve Table 기반으로 동적으로 조정 가능한 수치로 만들기 위해 사용하는 구조체이다.
단순한 float와 달리 레벨, 난이도, 상황에 따라 수치를 조정할 수 있는 기능을 제공한다.

에디터에서 Curve Table을 생성해서 BaseDamage 데이터를 정의한다. 그리고 BP_Axe에 WeaponBaseDamage를 저장해준다.

✔️ HeroCombatComponent

HeroCombatComponent.h

#pragma once

#include "CoreMinimal.h"
#include "Components/Combat/PawnCombatComponent.h"
#include "HeroCombatComponent.generated.h"

class AWarriorHeroWeapon;

UCLASS()
class RPG_API UHeroCombatComponent : public UPawnCombatComponent
{
	GENERATED_BODY()

public:
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	AWarriorHeroWeapon* GetHeroCarriedWeaponByTag(FGameplayTag InWeaponTag) const;
	
    // 현재 장착 중인 무기 반환
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	AWarriorHeroWeapon* GetHeroCurrentEquippedWeapon() const;
	
    // 현재 장착중인 무기 데미지 반환
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	float GetHeroCurrentEquippedWeaponDamageAtLevel(float InLevel) const;

	virtual void OnHitTargetActor(AActor* HitActor) override;
	virtual void OnWeaponPulledFromTargetActor(AActor* InteractedActor) override;

};

HeroCombatComponent.cpp

#include "Components/Combat/HeroCombatComponent.h"
#include "Items/Weapons/WarriorHeroWeapon.h"
#include "AbilitySystemBlueprintLibrary.h"
#include "RPGGameplayTags.h"

#include "WarriorDebugHelper.h"

AWarriorHeroWeapon* UHeroCombatComponent::GetHeroCurrentEquippedWeapon() const
{
	return Cast<AWarriorHeroWeapon>(GetCharacterCurrentEquippedWeapon());
}

float UHeroCombatComponent::GetHeroCurrentEquippedWeaponDamageAtLevel(float InLevel) const
{
	return GetHeroCurrentEquippedWeapon()->HeroWeaponData.WeaponBaseDamage.GetValueAtLevel(InLevel);
}

WeaponData를 하고 나서 현재 Level에 비례한 무기 데미지 반환 함수 구현한다.

✔️ RPGGameplayTags

RPGGameplayTags.h

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */
    
	/** Player Tags */

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_SetByCaller_AttackType_Light);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_SetByCaller_AttackType_Heavy);
}

RPGGameplayTags.cpp

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */

	/** Player Tags */
	UE_DEFINE_GAMEPLAY_TAG(Player_SetByCaller_AttackType_Light, "Player.SetByCaller.AttackType.Light");
	UE_DEFINE_GAMEPLAY_TAG(Player_SetByCaller_AttackType_Heavy, "Player.SetByCaller.AttackType.Heavy");
}

GameplayEffectSpec에 SetByCallerMagnitude 방식으로 공격 타입 정보를 담아 전달하기 위해, Tag를 선언한다.

GE Spec Handle 반환 함수에 데이터 연결

FGameplayEffectSpecHandle UWarriorHeroGameplayAbility::MakeHeroDamageEffectSpecHandle(
	TSubclassOf<UGameplayEffect> EffectClass, float InWeaponBaseDamage,
	FGameplayTag InCurrentAttackTypeTag, int32 InUsedComboCount)
{
	check(EffectClass);

	// 컨텍스트 생성: 누가, 어떤 상황에서 발동 했는지
	FGameplayEffectContextHandle ContextHandle = GetRPGAbilitySystemComponentFromActorInfo()->MakeEffectContext();
	ContextHandle.SetAbility(this);
	ContextHandle.AddSourceObject(GetAvatarActorFromActorInfo());
	ContextHandle.AddInstigator(GetAvatarActorFromActorInfo(), GetAvatarActorFromActorInfo());

	// 스펙 생성: 
	FGameplayEffectSpecHandle EffectSpecHandle = GetRPGAbilitySystemComponentFromActorInfo()->MakeOutgoingSpec(
		EffectClass,
		GetAbilityLevel(),
		ContextHandle
	);

	// 무기 기본 데미지 값 전달
	EffectSpecHandle.Data->SetSetByCallerMagnitude(
		RPGGameplayTags::Shared_SetByCaller_BaseDamage,
		InWeaponBaseDamage
	);

	// 공격 유형 태그를 키로, 콤보 수를 값으로 전달
	if (InCurrentAttackTypeTag.IsValid())
	{
		EffectSpecHandle.Data->SetSetByCallerMagnitude(InCurrentAttackTypeTag, InUsedComboCount);
	}

	return EffectSpecHandle;
}

EffectClass: 실행할 GE_Shared_DealDamage
InWeaponBaseDamage: Curve Table에서 레벨에 매칭되는 Damage
InCurrentAttackTypeTag: "Player.SetByCaller.AttackType.Light" Tag
InUsedComboCount: GameplayAbility의 현재 Combo Count 변수 값

위와 같이 데이터를 함수에 전달하였다.

FGameEffectSpecHandle로 대상에게 Damage 로직 구현

앞에서 생성한 GameplayEffectHandle을 대상 Actor에게 적용 시키는 기능을 하는 함수를 구현한다.
플레이어와 Enemy 모두 사용할 수 있도록 BaseGameplayAbility 클래스에 구현하도록 한다.

✔️ RPGEnumTypes.h

#pragma once

/** 생략 */

// 성공 여부 EnumType 구현
UENUM(BlueprintType)
enum class ERPGSuccessType : uint8
{
	Successful,
	Failed
};

Effect가 대상에게 실제로 적용되었는지 결과를 반환하기 위해 Enum 생성

✔️ RPGGameplayAbility

RPGGameplayAbility.h

#pragma once

#include "CoreMinimal.h"
#include "Abilities/GameplayAbility.h"
#include "RPGTypes/RPGEnumTypes.h"
#include "RPGGameplayAbility.generated.h"

class UPawnCombatComponent;
class URPGAbilitySystemComponent;

UENUM(BlueprintType)
enum class ERPGAbilityActivationPolicy : uint8
{
	OnTriggered,
	OnGiven
};

UCLASS()
class RPG_API URPGGameplayAbility : public UGameplayAbility
{
	GENERATED_BODY()
	
protected:

	/** 생략 */
    
    // GameplayEffectSpecHandle을 대상 액터에게 적용하는 헬퍼 함수
	FActiveGameplayEffectHandle NativeApplyEffectSpecHandleToTarget(AActor* TargetActor, const FGameplayEffectSpecHandle& InSpecHandle);
	
    // 위와 기능 동일하고 Effect 적용 결과를 Enum으로 반환하는 BP 전용 함수
	UFUNCTION(BlueprintCallable, Category = "RPGAbility", meta = (DisplayName = "Apply Gameplay Effect Spec Handle To Target", ExpandEnumAsExecs = "OutSuccessType"))
	FActiveGameplayEffectHandle BP_ApplyEffectSpecHandleToTarget(AActor* TargetActor, const FGameplayEffectSpecHandle& InSpecHandle, ERPGSuccessType& OutSuccessType);

};

RPGGameplayAbility.cpp

#include "AbilitySystem/Abilities/RPGGameplayAbility.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "Components/Combat/PawnCombatComponent.h"
#include "AbilitySystemBlueprintLibrary.h"

/** 생략 */

FActiveGameplayEffectHandle URPGGameplayAbility::NativeApplyEffectSpecHandleToTarget(AActor* TargetActor, const FGameplayEffectSpecHandle& InSpecHandle)
{
	// Effect가 처리될 대상의 ASC
	UAbilitySystemComponent* TargetASC = UAbilitySystemBlueprintLibrary::GetAbilitySystemComponent(TargetActor);

	check(TargetASC && InSpecHandle.IsValid());

	return GetRPGAbilitySystemComponentFromActorInfo()->ApplyGameplayEffectSpecToTarget(
		*InSpecHandle.Data, // SpecHandle에서 실제 FGameplaySpecHandle 전달
		TargetASC			// Effect 적용 대상의 ASC 전달
	);
}

FActiveGameplayEffectHandle URPGGameplayAbility::BP_ApplyEffectSpecHandleToTarget(AActor* TargetActor, const FGameplayEffectSpecHandle& InSpecHandle, ERPGSuccessType& OutSuccessType)
{
	FActiveGameplayEffectHandle ActiveGameplayEffectHandle = NativeApplyEffectSpecHandleToTarget(TargetActor, InSpecHandle);

	OutSuccessType = ActiveGameplayEffectHandle.WasSuccessfullyApplied() ? ERPGSuccessType::Successful : ERPGSuccessType::Failed;

	return ActiveGameplayEffectHandle;
}

GameplayEffect를 대상 Actor의 ASC에 적용시키는 함수 구현

에디터로 돌아와 GA_LightAttack에서 방금 구현한 함수로 GameplayEffect를 적용시키는 로직을 추가한다.

로직 흐름

Wait Gameplay Event 수신
- Shared.Event.MeleeHit 태그를 가진 이벤트를 수신
- 적이 무기에 피격 되었을 때, SendGameplayEventToActor( ) 를 통해 호출
- Payload로 GameplayEventData를 전달
Gameplay Event Data에서 Target 추출
- 여기서 추출한 Target은 피격 판정된 적 캐릭터(AActor)
Make Hero Damage Effect Spec 호출
- 데미지 계산 수행하는 클래스 포함한 GameplayEffect
- Weapon클래스 데이터에 있는 BaseDamage
- 데미지 계산을 위한 공격 Type Tag
- 현재 Combo Count
- 위의 데이터를 SpecHandle에 저장하고 반환
Apply Gameplay Effect Spec Handle To Target 호출
- 피격 처리할 대상(Target)에게 SpecHandle 적용
- Apply 시점에 SpecHandle에 저장된 정보를 바탕으로 데미지 계산
- Target의 ASC를 찾아 GameplayEffect 적용
- FActiveGameplayEffectHandle 반환 및 성공 여부 핀으로 전달

Attribute 캡처 및 피해량 계산

앞서 데미지 계산을 수행하는 클래스(Execution Calculation)를 포함한 GameEffect를 만들었고, 이 GE를 대상 Actor에게 적용시키는 로직을 구현하였다.
하지만 클래스 생성만 해놓고, 데미지 계산 로직을 비워둔 상태로 GE 적용만 시켰기 때문에 현재는 피격당하더라도 데미지를 입을 수 없다.
따라서 이제 데미지 계산 로직을 수행하는 클래스를 구현하도록 한다.

GameplayEffectExecutionCalculation 클래스는 단순히 GameplayEffect에 설정된 Modifier만으로는 할 수 없는 동적인 계산(공격력 - 방어력 등)을 처리하기 위한 클래스이다.
이 클래스는 실제 계산을 할 때, 지정된 Attribute를 "캡처"해서 값으로 사용할 수 있도록 설정해야한다.

즉, Execute 함수 내부에서 값을 가져오려면, 사전에 어떤 값을 사용할 것인지 명시적으로 등록해야 하며, 이 등록이 RelevantAttributesToCapture 배열에 추가되는 "Attribute Capture Definition"이다.

캡처하는 방법에는 "직접 수동으로 캡처를 하는 방법" 과 "매크로 + 구조체를 사용한 방법"이 있다.
당연히 전자 쪽이 코드 작성이 더 많고 구현하는데 오래걸리므로 후자 쪽 방향으로 구현할 것이다.

캡처 정의 2가지 방법

수동 캡쳐 정의

UGEExecCalc_Damage::UGEExecCalc_Damage()
{
	/** 수동 캡처 */
	FProperty* AttackPowerProperty = FindFieldChecked<FProperty>(
		URPGAttributeSet::StaticClass(),
		GET_MEMBER_NAME_CHECKED(URPGAttributeSet, AttackPower)
	);

	FGameplayEffectAttributeCaptureDefinition AttackPowerCaptureDefinition(
		AttackPowerProperty,
		EGameplayEffectAttributeCaptureSource::Source,
		false
	);
    
    FProperty* DefensePowerProperty = FindFieldChecked<FProperty>(
		URPGAttributeSet::StaticClass(),
		GET_MEMBER_NAME_CHECKED(URPGAttributeSet, DefensePower)
	);

	FGameplayEffectAttributeCaptureDefinition DefensePowerCaptureDefinition(
		DefensePowerProperty,
		EGameplayEffectAttributeCaptureSource::Target,
		false
	);

	RelevantAttributesToCapture.Add(AttackPowerCaptureDefinition);
    RelevantAttributesToCapture.Add(DefensePowerCaptureDefinition);
}

매크로 + 구조체 사용한 정의

#include "AbilitySystem/GEExecCalc/GEExecCalc_Damage.h"
#include "AbilitySystem/RPGAttributeSet.h"

struct FRPGDamageCaputre
{
	DECLARE_ATTRIBUTE_CAPTUREDEF(AttackPower)
	DECLARE_ATTRIBUTE_CAPTUREDEF(DefensePower)
    
	FRPGDamageCaputre()
	{
		DEFINE_ATTRIBUTE_CAPTUREDEF(URPGAttributeSet, AttackPower, Source, false)
		DEFINE_ATTRIBUTE_CAPTUREDEF(URPGAttributeSet, DefensePower, Target, false)
	}
};

static const FRPGDamageCaputre& GetRPGDamageCaputre()
{
	static FRPGDamageCaputre RPGDamageCaputre;
	return RPGDamageCaputre;
}

UGEExecCalc_Damage::UGEExecCalc_Damage()
{
	RelevantAttributesToCapture.Add(GetRPGDamageCaputre().AttackPowerDef);
    RelevantAttributesToCapture.Add(GetRPGDamageCaputre().DefensePowerDef);
}

여러 값을 캡처한다고 했을 때, 매크로 + 구조체를 사용하는 것이 더 코드가 간결해질 것이라는 것을 확인할 수 있다.
자세한 매크로 내부는 "UGameplayEffectExecutionCalculation.h"에 정의되어있다.

✅ 데미지 계산 클래스 기능 구현

✔️ RPGAttributeSet

RPGAttributeSet.h

#pragma once

#include "CoreMinimal.h"
#include "AttributeSet.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "RPGAttributeSet.generated.h"

#define ATTRIBUTE_ACCESSORS(ClassName, PropertyName) \
GAMEPLAYATTRIBUTE_PROPERTY_GETTER(ClassName, PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_GETTER(PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_SETTER(PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_INITTER(PropertyName)

UCLASS()
class RPG_API URPGAttributeSet : public UAttributeSet
{
	GENERATED_BODY()
	
public:
	URPGAttributeSet();

	/** 생략 */

	UPROPERTY(BlueprintReadOnly, Category = "Damage")
	FGameplayAttributeData AttackPower;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, AttackPower)

	UPROPERTY(BlueprintReadOnly, Category = "Damage")
	FGameplayAttributeData DefensePower;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, DefensePower)

	UPROPERTY(BlueprintReadOnly, Category = "Damage")
	FGameplayAttributeData DamageTaken;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, DamageTaken) // 최종 계산된 데미지 저장할 Attribute

};

ExecutionCalculation에서 계산된 최종 데미지를 저장하는 용도의 Attribute인 "DamageTaken" 선언한다.
실제 체력 감소 처리 로직에서 이 속성 값이 사용된다.

✔️ GEExecCalc_Damage

GEExecCalc_Damage.h

#pragma once

#include "CoreMinimal.h"
#include "GameplayEffectExecutionCalculation.h"
#include "GEExecCalc_Damage.generated.h"

UCLASS()
class RPG_API UGEExecCalc_Damage : public UGameplayEffectExecutionCalculation
{
	GENERATED_BODY()
	
public:
	// 생성자에서 Attribute를 계산을 위해 캡처
	// 매크로 + 구조체 방식으로 캡처
	UGEExecCalc_Damage();
	
    // 계산 실행 함수
	virtual void Execute_Implementation(
		const FGameplayEffectCustomExecutionParameters& ExecutionParams,
		FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const override;

};

GEExecCalc_Damage.cpp

#include "AbilitySystem/GEExecCalc/GEExecCalc_Damage.h"
#include "AbilitySystem/RPGAttributeSet.h"
#include "RPGGameplayTags.h"

#include "WarriorDebugHelper.h"

struct FRPGDamageCaputre
{
	DECLARE_ATTRIBUTE_CAPTUREDEF(AttackPower)
	DECLARE_ATTRIBUTE_CAPTUREDEF(DefensePower)
	DECLARE_ATTRIBUTE_CAPTUREDEF(DamageTaken)

	FRPGDamageCaputre()
	{
		DEFINE_ATTRIBUTE_CAPTUREDEF(URPGAttributeSet, AttackPower, Source, false)
		DEFINE_ATTRIBUTE_CAPTUREDEF(URPGAttributeSet, DefensePower, Target, false)
		DEFINE_ATTRIBUTE_CAPTUREDEF(URPGAttributeSet, DamageTaken, Target, false)
	}
};

static const FRPGDamageCaputre& GetRPGDamageCaputre()
{
	static FRPGDamageCaputre RPGDamageCaputre;
	return RPGDamageCaputre;
}

UGEExecCalc_Damage::UGEExecCalc_Damage()
{
	RelevantAttributesToCapture.Add(GetRPGDamageCaputre().AttackPowerDef);
	RelevantAttributesToCapture.Add(GetRPGDamageCaputre().DefensePowerDef);
	RelevantAttributesToCapture.Add(GetRPGDamageCaputre().DamageTakenDef);
}

void UGEExecCalc_Damage::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams, FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
{
	// 1.EffectSpec 준비
	const FGameplayEffectSpec& EffectSpec = ExecutionParams.GetOwningSpec();

	/** Effect Spec이 가지고 있는 ContextHandle에서 정보 가져올 수 있음 */
	/*EffectSpec.GetContext().GetSourceObject();
	EffectSpec.GetContext().GetAbility();
	EffectSpec.GetContext().GetInstigator();
	EffectSpec.GetContext().GetEffectCauser();*/

	// 2.EvaluateParameters 생성(속성 계산에 사용할 태그 정보)
	FAggregatorEvaluateParameters EvaluateParameters;
	EvaluateParameters.SourceTags = EffectSpec.CapturedSourceTags.GetAggregatedTags();
	EvaluateParameters.TargetTags = EffectSpec.CapturedTargetTags.GetAggregatedTags();

	// 3.Source(공격자)의 AttackPower 추출
	float SourceAttackPower = 0.0f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(GetRPGDamageCaputre().AttackPowerDef, EvaluateParameters, SourceAttackPower);
	Debug::Print(TEXT("SourceAttackPower"), SourceAttackPower);

	// 4.SetByCaller 값(BaseDamage, Light/Heavy Attack Combo Count) 추출
	//   Ability에서 SetSetByCallerMagnitude로 전달한 값을 TMap에서 추출하는 것
	float BaseDamage = 0.0f;
	int32 UsedLightAttackComboCount = 0;
	int32 UsedHeavyAttackComboCount = 0;

	for(const TPair<FGameplayTag, float>& TagMagnitude : EffectSpec.SetByCallerTagMagnitudes)
	{
		if (TagMagnitude.Key.MatchesTagExact(RPGGameplayTags::Shared_SetByCaller_BaseDamage))
		{
			BaseDamage = TagMagnitude.Value;
			Debug::Print(TEXT("BaseDamage"), BaseDamage);
		}

		if (TagMagnitude.Key.MatchesTagExact(RPGGameplayTags::Player_SetByCaller_AttackType_Light))
		{
			UsedLightAttackComboCount = TagMagnitude.Value;
			Debug::Print(TEXT("UsedLightAttackComboCount"), UsedLightAttackComboCount);
		}

		if (TagMagnitude.Key.MatchesTagExact(RPGGameplayTags::Player_SetByCaller_AttackType_Heavy))
		{
			UsedHeavyAttackComboCount = TagMagnitude.Value;
			Debug::Print(TEXT("UsedHeavyAttackComboCount"), UsedHeavyAttackComboCount);
		}
	}

	// 5.Target(피격자)의 DefensePower 추출
	float TargetDefensePower = 0.0f;
	ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(GetRPGDamageCaputre().DefensePowerDef, EvaluateParameters, TargetDefensePower);
	Debug::Print(TEXT("TargetDefensePower"), TargetDefensePower);

	// 6.Combo Count에 따른 Damage 보정
	if (UsedLightAttackComboCount != 0)
	{
		const float DamageIncreasePercentLight = (UsedLightAttackComboCount - 1) * 0.05 + 1.0f;

		BaseDamage *= DamageIncreasePercentLight;
		Debug::Print(TEXT("ScaledBaseDamageLight"), BaseDamage);
	}

	if (UsedHeavyAttackComboCount != 0)
	{
		const float DamageIncreasePercentHeavy = UsedHeavyAttackComboCount * 0.15f + 1.0f;

		BaseDamage *= DamageIncreasePercentHeavy;
		Debug::Print(TEXT("ScaledBaseDamageHeavy"), BaseDamage);
	}

	// 7.최종 피해량 계산
	const float FinalDamageDone = BaseDamage * SourceAttackPower / TargetDefensePower;
	Debug::Print(TEXT("FinalDamageDone"), FinalDamageDone);

	// 8.피해량 적용
	// 캡처한 DamageTaken Attribute에 Override 방식으로 최종 피해량 적용
	if (FinalDamageDone > 0.0f)
	{
		OutExecutionOutput.AddOutputModifier(
			FGameplayModifierEvaluatedData(
				GetRPGDamageCaputre().DamageTakenProperty,
				EGameplayModOp::Override,
				FinalDamageDone
			)
		);
	}
}

GameplaySpec에서 전달 받은 데이터(기본 데미지, 공격력, 방어력 등)을 캡처하여 최종 피해량 계산 후, "DamageTaken" 이라는 Attribute에 데이터 Override 하였다.

데미지 계산하여, 최종 데미지 도출 결과

내부적으로 GE가 Apply될 때, 정상적으로 데미지 계산이 이루어지는 것을 확인할 수 있었다.

현재 체력에 데미지 적용

앞서 계산된 최종 데미지를 현제 체력에 적용하고, 캐릭터가 데미지를 입고 죽는지 판단하는 로직을 "Attribute Set" 내부에서 처리하도록 할 것이다.

✔️ RPGAttributeSet

RPGAttributeSet.h

#pragma once

#include "CoreMinimal.h"
#include "AttributeSet.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "RPGAttributeSet.generated.h"

#define ATTRIBUTE_ACCESSORS(ClassName, PropertyName) \
GAMEPLAYATTRIBUTE_PROPERTY_GETTER(ClassName, PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_GETTER(PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_SETTER(PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_INITTER(PropertyName)

UCLASS()
class RPG_API URPGAttributeSet : public UAttributeSet
{
	GENERATED_BODY()
	
public:
	URPGAttributeSet();

	// GE에 의해 Attribute 값에 Modifier가 적용되면, 자동으로 호출되는 콜백 함수
	virtual void PostGameplayEffectExecute(const struct FGameplayEffectModCallbackData& Data) override;

	/** 생략 */

	UPROPERTY(BlueprintReadOnly, Category = "Damage")
	FGameplayAttributeData AttackPower;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, AttackPower)

	UPROPERTY(BlueprintReadOnly, Category = "Damage")
	FGameplayAttributeData DefensePower;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, DefensePower)

	UPROPERTY(BlueprintReadOnly, Category = "Damage")
	FGameplayAttributeData DamageTaken;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, DamageTaken)

};

RPGAttributeSet.cpp

#include "AbilitySystem/RPGAttributeSet.h"
#include "GameplayEffectExtension.h"

#include "WarriorDebugHelper.h"

URPGAttributeSet::URPGAttributeSet()
{
	InitCurrentHealth(1.0f);
	InitMaxHealth(1.0f);
	InitCurrentRage(1.0f);
	InitMaxRage(1.0f);
	InitAttackPower(1.0f);
	InitDefensePower(1.0f);
}

void URPGAttributeSet::PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data)
{
	// GE 실행 결과로 Modifier가 적용된 Attribute가 CurrentHealth라면 해당 로직 실행
	if (Data.EvaluatedData.Attribute == GetCurrentHealthAttribute())
	{
		const float NewCurrentHealth = FMath::Clamp(GetCurrentHealth(), 0.0f, GetMaxHealth());

		SetCurrentHealth(NewCurrentHealth);
	}

	if (Data.EvaluatedData.Attribute == GetCurrentRageAttribute())
	{
		const float NewCurrentRage = FMath::Clamp(GetCurrentRage(), 0.0f, GetMaxRage());

		SetCurrentRage(NewCurrentRage);
	}

	if (Data.EvaluatedData.Attribute == GetDamageTakenAttribute())
	{
		const float OldHealth = GetCurrentHealth();
		const float DamageDone = GetDamageTaken();

		const float NewCurrentHealth = FMath::Clamp(OldHealth - DamageDone, 0.0f, GetMaxHealth());

		SetCurrentHealth(NewCurrentHealth);

		const FString DebugString = FString::Printf(
			TEXT("Old Health %f, Damage Done: %f, NewCurrentHealth: %f"),
			OldHealth,
			DamageDone,
			NewCurrentHealth
		);

		Debug::Print(DebugString, FColor::Green);

		// TODO::사망 처리
		if (NewCurrentHealth == 0.0f)
		{
			// 사망 관련 태그 추가 -> DeathAbility 실행 등
		}
	}
}

GameplayEffect가 Modifier를 Attribute에 적용시키면 자동으로 호출되며 해당 로직들이 동작한다.
추후 현재 체력이 0이라면 사망관련 Tag를 부여하고 ASC가 이를 감지해 DeathAbility를 실행시키는 구조로 간다면 자연스럽게 사망로직이 구현될 것이다.

데미지 적용 테스트 결과

LogTemp: Warning: FinalDamageDone: 16.0
LogTemp: Warning: Old Health 75.000000, Damage Done: 16.000000, NewCurrentHealth: 59.000000
LogTemp: Warning: FinalDamageDone: 16.799999
LogTemp: Warning: Old Health 59.000000, Damage Done: 16.799999, NewCurrentHealth: 42.200001
LogTemp: Warning: FinalDamageDone: 17.600002
LogTemp: Warning: Old Health 42.200001, Damage Done: 17.600002, NewCurrentHealth: 24.599998
LogTemp: Warning: FinalDamageDone: 20.799999
LogTemp: Warning: Old Health 24.599998, Damage Done: 20.799999, NewCurrentHealth: 3.799999
LogTemp: Warning: FinalDamageDone: 16.0
LogTemp: Warning: Old Health 3.799999, Damage Done: 16.000000, NewCurrentHealth: 0.000000
LogTemp: Warning: FinalDamageDone: 16.799999
LogTemp: Warning: Old Health 0.000000, Damage Done: 16.799999, NewCurrentHealth: 0.000000
LogTemp: Warning: FinalDamageDone: 18.4
LogTemp: Warning: Old Health 0.000000, Damage Done: 18.400000, NewCurrentHealth: 0.000000

AI의 체력이 FinalDamage만큼 감소하고, 체력이 0이 되었을 때 그 이하로 떨어지지 않는 것을 확인할 수 있었다.

GAS_12_피격 판정

동그래님 — Fri, 9 May 2025 12:50:22 +0900

근접 무기 충돌 Toggle 시스템

무기 출돌 활성/ 비활성화를 애니메이션 타이밍에 맞춰 제어하기 위해 Toggle 시스템을 구현한다.
공격 애니메이션의 특정 시점에 무기 충돌을 활성화 하고, 이후 다시 비활성화하여 정확한 타격 판정을 가능하게 하기 위함이다.

Hero 무기의 Collision을 살펴보면 No Collision으로 되어있고, AnimMontage의 무기 휘두르는 특정 구간을 AnimNotifyState로 Collision 활성화할 것이다.

✅ PawnCombatInterface 클래스 생성

"Unreal Interface"를 상속 받는 "PawnCombatInterface" C++ 클래스를 생성한다.

PawnCombatInterface.h

#pragma once

#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "PawnCombatInterface.generated.h"

class UPawnCombatComponent;

UINTERFACE(MinimalAPI)
class UPawnCombatInterface : public UInterface
{
	GENERATED_BODY()
};

class RPG_API IPawnCombatInterface
{
	GENERATED_BODY()

public:
	virtual UPawnCombatComponent* GetPawnCombatComponent() const = 0;
};

PawnCombatComponent를 반환하는 순수가상함수를 선언한다.

✅ PawnCombatInterface 상속 및 함수 구현

✔️ RPGBaseCharacter 클래스

RPGBaseCharacter.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "AbilitySystemInterface.h"
#include "Interfaces/PawnCombatInterface.h" // Interface 헤더 추가
#include "RPGBaseCharacter.generated.h"

class URPGAbilitySystemComponent;
class URPGAttributeSet;
class UDataAsset_StartUpDataBase;

UCLASS()
class RPG_API ARPGBaseCharacter : public ACharacter, public IAbilitySystemInterface, public IPawnCombatInterface // Interface 상속
{
	GENERATED_BODY()

public:
	ARPGBaseCharacter();

	//~ Begin IAbilitySystemInterface Interface
	virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override;
	//~ End IAbilitySystemInterface Interface.

	//~ Begin IPawnCombatInterface Interface
	virtual UPawnCombatComponent* GetPawnCombatComponent() const override; // 순수 가상함수 Override
	//~ End IPawnCombatInterface Interface.
}

RPGBaseCharacter.cpp

UPawnCombatComponent* ARPGEnemyCharacter::GetPawnCombatComponent() const
{
	return EnemyCombatComponent;
}

BaseCharacter 클래스에서 "PawnCombatInterface"를 상속받고, "GetPawnCombatComponent()" 순수 가상함수를 선언 및 구현한다.

✔️ Hero/Enemy Character클래스

WarriorHeroCharacter.h

UCLASS()
class RPG_API AWarriorHeroCharacter : public ARPGBaseCharacter
{
	GENERATED_BODY()
	
public:
	AWarriorHeroCharacter();

	//~ Begin IPawnCombatInterface Interface
	virtual UPawnCombatComponent* GetPawnCombatComponent() const override;
	//~ End IPawnCombatInterface Interface.
}

WarriorHeroCharacter.cpp

AWarriorHeroCharacter::AWarriorHeroCharacter()
{
	/** 생략 */

	HeroCombatComponent = CreateDefaultSubobject<UHeroCombatComponent>(TEXT("HeroCombatComponent"));
}

UPawnCombatComponent* AWarriorHeroCharacter::GetPawnCombatComponent() const
{
	return HeroCombatComponent;
}

RPGEnemyCharacter.h

UCLASS()
class RPG_API ARPGEnemyCharacter : public ARPGBaseCharacter
{
	GENERATED_BODY()
	
public:
	ARPGEnemyCharacter();

	//~ Begin IPawnCombatInterface Interface
	virtual UPawnCombatComponent* GetPawnCombatComponent() const override;
	//~ End IPawnCombatInterface Interface.
}

RPGEnemyCharacter.cpp

ARPGEnemyCharacter::ARPGEnemyCharacter()
{
	/** 생략 */

	EnemyCombatComponent = CreateDefaultSubobject<UEnemyCombatComponent>(TEXT("EnemyCombatComponent"));
}

UPawnCombatComponent* ARPGEnemyCharacter::GetPawnCombatComponent() const
{
	return EnemyCombatComponent;
}

HeroCharacter, EnemyCharacter 모두 "GetPawnCombatComponent" 함수를 재정의 하여, 각각 가지고 있는 CombatComponent를 반환하도록 구현한다.

✅ PawnCombatComponent 반환 라이브러리 함수 구현

✔️ RPGFunctionLibrary 클래스

RPGFunctionLibrary.h

#pragma once

#include "CoreMinimal.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "GameplayTagContainer.h"
#include "RPGTypes/RPGEnumTypes.h"
#include "RPGFunctionLibrary.generated.h"

class URPGAbilitySystemComponent;
class UPawnCombatComponent;

UCLASS()
class RPG_API URPGFunctionLibrary : public UBlueprintFunctionLibrary
{
	GENERATED_BODY()
	
public:
	static URPGAbilitySystemComponent* NativeGetRPGASC_FormActor(AActor* InActor);

	static bool NativeDoesActorHaveTag(AActor* InActor, FGameplayTag TagToCheck);

	UFUNCTION(BlueprintCallable, Category = "RPG|FunctionLibrary")
	static void AddGameplayTagToActorIfNone(AActor* InActor, FGameplayTag TagToAdd);

	UFUNCTION(BlueprintCallable, Category = "RPG|FunctionLibrary")
	static void RemoveGameplayTagFromActorIfFound(AActor* InActor, FGameplayTag TagToRemove);

	UFUNCTION(BlueprintCallable, Category = "RPG|FunctionLibrary", meta = (DisplayName = "Does Actor Have Tag", ExpandEnumAsExecs = "OutConfirmType"))
	static void BP_DoesActorHaveTag(AActor* InActor, FGameplayTag TagToCheck, ERPGConfirmType& OutConfirmType);

	// PawnCombatComponent를 반환
	static UPawnCombatComponent* NativeGetPawnCombatComponentFromActor(AActor* InActor);

	// BP에서 PawnCombatComponent를 반환 + Enum 타입 반환
	UFUNCTION(BlueprintCallable, Category = "RPG|FunctionLibrary", meta = (DisplayName = "Get Pawn Combat Component From Actor", ExpandEnumAsExecs = "OutVaildType"))
	static UPawnCombatComponent* BP_GetPawnCombatComponentFromActor(AActor* InActor, ERPGValidType& OutVaildType);
	
};

RPGFunctionLibrary.h

#include "RPGFunctionLibrary.h"
#include "AbilitySystemBlueprintLibrary.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "Components/Combat/PawnCombatComponent.h"
#include "Interfaces/PawnCombatInterface.h"

UPawnCombatComponent* URPGFunctionLibrary::NativeGetPawnCombatComponentFromActor(AActor* InActor)
{
	check(InActor);

	if (IPawnCombatInterface* PawnCombatInterface = Cast<IPawnCombatInterface>(InActor))
	{
		return PawnCombatInterface->GetPawnCombatComponent();
	}

	return nullptr;
}

UPawnCombatComponent* URPGFunctionLibrary::BP_GetPawnCombatComponentFromActor(AActor* InActor, ERPGValidType& OutVaildType)
{
	UPawnCombatComponent* CombatComponent = NativeGetPawnCombatComponentFromActor(InActor);

	OutVaildType = CombatComponent ? ERPGValidType::Vaild : ERPGValidType::InVaild;

	return CombatComponent;
}

블루프린트(AnimNotifyState)내에서 쉽게 PawnCombatComponent를 가져오고 유효성 검사도 동시에 진행하는 Library 함수를 구현한다.

✅ PawnCombatCompont에 ToggleCollision 기능 구현

✔️ PawnCombatComponent

PawnCombatComponent.h

#pragma once

#include "CoreMinimal.h"
#include "Components/PawnExtensionComponentBase.h"
#include "GameplayTagContainer.h"
#include "PawnCombatComponent.generated.h"

class ARPGWeaponBase;

// 데미지 주체 타입 정의
UENUM(BlueprintType)
enum class EToggleDamageType : uint8
{
	CurrentEquippedWeapon,
	LeftHand,
	RightHand
};

UCLASS()
class RPG_API UPawnCombatComponent : public UPawnExtensionComponentBase
{
	GENERATED_BODY()
	
public:
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	void RegisterSpawnedWeapon(FGameplayTag InWeaponTagToRegister, ARPGWeaponBase* InWeaponToRegister, bool bRegisterAsEquippedWeapon = false);

	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	ARPGWeaponBase* GetCharacterCarriedWeaponByTag(FGameplayTag InWeaponTagToGet) const;

	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	ARPGWeaponBase* GetCharacterCurrentEquippedWeapon() const;
    
	// 콜리전 (비)활성화 Toggle 기능
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	void ToggleWeaponCollision(bool bShouldEnable, EToggleDamageType ToggleDamageType = EToggleDamageType::CurrentEquippedWeapon);

	UPROPERTY(BlueprintReadWrite, Category = "RPG|Combat")
	FGameplayTag CurrentEquippedWeaponTag;

private:
	TMap<FGameplayTag, ARPGWeaponBase*> CharacterCarriedWeaponMap;
};

PawnCombatComponent.cpp

#include "Components/Combat/PawnCombatComponent.h"
#include "Items/Weapons/RPGWeaponBase.h"
#include "Components/BoxComponent.h"

#include "WarriorDebugHelper.h"

/** 생략 */

void UPawnCombatComponent::ToggleWeaponCollision(bool bShouldEnable, EToggleDamageType ToggleDamageType)
{
	if (ToggleDamageType == EToggleDamageType::CurrentEquippedWeapon)
	{
		ARPGWeaponBase* WeaponToToggle = GetCharacterCurrentEquippedWeapon();

		check(WeaponToToggle);

		if (bShouldEnable)
		{
			WeaponToToggle->GetWeaponCollisionBox()->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
			Debug::Print(WeaponToToggle->GetName() + TEXT("Collision Enabled"), FColor::Green);
		}
		else
		{
			WeaponToToggle->GetWeaponCollisionBox()->SetCollisionEnabled(ECollisionEnabled::NoCollision);
			Debug::Print(WeaponToToggle->GetName() + TEXT("Collision Disabled"), FColor::Red);
		}
		
	}
}

데미지 타입이 착용 중인 무기라면, bool 값에 따라 무기의 Collision을 설정하도록 한다.

✅ 공격 시, 콜리전 (비)활성화 적용

✔️ Anim Notify State_ToggleWeaponCollision 구현

에디터로 돌아와 AnimNotifyState를 상속 받는 BP 클래스를 생성한다. "ANS_ToggleWeaponCollision"으로 명명한다.

1. MeshComponent에서 "GetOwner"로 Actor를 가져온다.
2. 앞서 Fuction Library에서 구현했던 "GetPawnCombatComponentFromActor" 함수에 Actor를 전달해서 "PawnCombatComponent를 반환 받는다.
3. "PawnCombatComponent"의 "ToggleWeaponCollision" 함수를 통해 해당 무기의 콜리전을 (비)활성화 한다.

✔️ 공격 Montage에 ANS 적용

공격 판정이 필요한 지점에 "ANS_ToggleWeaponCollision" 설정을 진행한다.

Collision 활성화 테스트

무기를 휘두르기 시작한 지점에 Collision이 활성화되고, 휘두르는 동작 End지점에서 Collision이 다시 비활성화 되는 것을 확인할 수 있다.

콜리전으로 피격 대상 감지

무기로 공격할 때, 적절한 시점에 Collision을 활성화 하고, 휘두르는 동작이 끝나면 Collision이 비활성화 되는 것까지 구현이 되었다.
이제 실제로 Collision에 Overlap된 대상이 누구인지 감지하도록 한다.

✔️ RPGGameplayTags

RPGGameplayTags.h

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */

	/** Shared Tags */
	UE_DEFINE_GAMEPLAY_TAG(Shared_Event_MeleeHit, "Shared.Event.MeleeHit");
}

RPGGameplayTags.cpp

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** 생략 */

	/** Shared Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Shared_Event_MeleeHit);

}

피격 상황 발생 시, 해당 태그로 Ability에서 Event를 감지하도록 한다.

✔️ RPGWeaponBase

RPGWeaponBase.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "RPGWeaponBase.generated.h"

class UBoxComponent;

DECLARE_DELEGATE_OneParam(FOnTargetInterfacedDelegate, AActor*) // 인자 하나를 넘길 수 있는 델리게이트 선언

UCLASS()
class RPG_API ARPGWeaponBase : public AActor
{
	GENERATED_BODY()
	
public:	
	ARPGWeaponBase();

	FOnTargetInterfacedDelegate OnWeaponHitTarget;
	FOnTargetInterfacedDelegate OnWeaponPulledFromTarget;

protected:
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Weapons")
	UStaticMeshComponent* WeaponMesh;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Weapons")
	UBoxComponent* WeaponCollisionBox;

	UFUNCTION()
	virtual void OnCollisionBoxBeginOverlap( // 오버랩 시작 시 호출 함수
		UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
		UPrimitiveComponent* OtherComp, int32 OtherBodyIndex,
		bool bFromSweep, const FHitResult& SweepResult);

	UFUNCTION()
	virtual void OnCollisionBoxEndOverlap( // 오버랩 종료 시 호출 함수
		UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
		UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);

public:
	FORCEINLINE UBoxComponent* GetWeaponCollisionBox() const { return WeaponCollisionBox; }
};

RPGWeaponBase.cpp

#include "Items/Weapons/RPGWeaponBase.h"
#include "Components/BoxComponent.h"

#include "WarriorDebugHelper.h"

ARPGWeaponBase::ARPGWeaponBase()
{
	PrimaryActorTick.bCanEverTick = false;

	WeaponMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("WeaponMesh"));
	SetRootComponent(WeaponMesh);

	WeaponCollisionBox = CreateDefaultSubobject<UBoxComponent>(TEXT("WeaponCollisionBox"));
	WeaponCollisionBox->SetupAttachment(GetRootComponent());
	WeaponCollisionBox->SetBoxExtent(FVector(20.0f));
	WeaponCollisionBox->SetCollisionEnabled(ECollisionEnabled::NoCollision);
	
    // Box Collision에 Overlap Event 발생 시, 호출될 함수 바인딩
	WeaponCollisionBox->OnComponentBeginOverlap.AddUniqueDynamic(this, &ARPGWeaponBase::OnCollisionBoxBeginOverlap);
	WeaponCollisionBox->OnComponentEndOverlap.AddUniqueDynamic(this, &ARPGWeaponBase::OnCollisionBoxEndOverlap);
}

void ARPGWeaponBase::OnCollisionBoxBeginOverlap(
	UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
	UPrimitiveComponent* OtherComp, int32 OtherBodyIndex,
	bool bFromSweep, const FHitResult& SweepResult)
{
	APawn* WeaponOwningPawn = GetInstigator<APawn>();

	checkf(WeaponOwningPawn, TEXT("Forgot to assign an instigator as the owning pawn for the weapon: %s"), *GetName());

	if (APawn* HitPawn = Cast<APawn>(OtherActor))
	{
		if (WeaponOwningPawn != HitPawn)
		{
			OnWeaponHitTarget.ExecuteIfBound(OtherActor); // BroadCast 실행
		}
	}
}

void ARPGWeaponBase::OnCollisionBoxEndOverlap(
	UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
	UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	APawn* WeaponOwningPawn = GetInstigator<APawn>();

	checkf(WeaponOwningPawn, TEXT("Forgot to assign an instigator as the owning pawn for the weapon: %s"), *GetName());

	if (APawn* HitPawn = Cast<APawn>(OtherActor))
	{
		if (WeaponOwningPawn != HitPawn)
		{
			OnWeaponPulledFromTarget.ExecuteIfBound(OtherActor); // BroadCast 실행
		}
	}
}

BaseWeapon 클래스에 콜리전에 오버랩 이벤트 발생 시, 델리게이트 구독한 클래스 객체들에게 BroadCasting 하도록 구현한다.

✔️ PawnCombatComponent

PawnCombatComponent.h

#pragma once

#include "CoreMinimal.h"
#include "Components/PawnExtensionComponentBase.h"
#include "GameplayTagContainer.h"
#include "PawnCombatComponent.generated.h"

class ARPGWeaponBase;

UENUM(BlueprintType)
enum class EToggleDamageType : uint8
{
	CurrentEquippedWeapon,
	LeftHand,
	RightHand
};

UCLASS()
class RPG_API UPawnCombatComponent : public UPawnExtensionComponentBase
{
	GENERATED_BODY()
	
public:
	// Tag 기반으로 무기를 Map에 저장, 현재 장착된 무기 정보 갱신
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	void RegisterSpawnedWeapon(FGameplayTag InWeaponTagToRegister, ARPGWeaponBase* InWeaponToRegister, bool bRegisterAsEquippedWeapon = false);
	
    /** 생략 */
    
	// 콜리전 (비)활성화 Toggle 기능
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	void ToggleWeaponCollision(bool bShouldEnable, EToggleDamageType ToggleDamageType = EToggleDamageType::CurrentEquippedWeapon);

	virtual void OnHitTargetActor(AActor* HitActor);
	virtual void OnWeaponPulledFromTargetActor(AActor* InteractedActor);
	
protected:
	TArray<AActor*> OverlappedActors;

private:
	TMap<FGameplayTag, ARPGWeaponBase*> CharacterCarriedWeaponMap;
};

PawnCombatComponent.cpp

#include "Components/Combat/PawnCombatComponent.h"
#include "Items/Weapons/RPGWeaponBase.h"
#include "Components/BoxComponent.h"

void UPawnCombatComponent::RegisterSpawnedWeapon(FGameplayTag InWeaponTagToRegister, ARPGWeaponBase* InWeaponToRegister, bool bRegisterAsEquippedWeapon)
{
	checkf(!CharacterCarriedWeaponMap.Contains(InWeaponTagToRegister), 
		TEXT("A named %s has already been added as carried weapon"), 
		*InWeaponTagToRegister.ToString());
	check(InWeaponToRegister);

	CharacterCarriedWeaponMap.Emplace(InWeaponTagToRegister, InWeaponToRegister);

	// 무기에 Overlap Event 발생시 호출될 함수 바인딩
	InWeaponToRegister->OnWeaponHitTarget.BindUObject(this, &ThisClass::OnHitTargetActor);
	InWeaponToRegister->OnWeaponPulledFromTarget.BindUObject(this, &ThisClass::OnWeaponPulledFromTargetActor);

	if (bRegisterAsEquippedWeapon)
	{
		CurrentEquippedWeaponTag = InWeaponTagToRegister;
	}
}

void UPawnCombatComponent::ToggleWeaponCollision(bool bShouldEnable, EToggleDamageType ToggleDamageType)
{
	if (ToggleDamageType == EToggleDamageType::CurrentEquippedWeapon)
	{
		ARPGWeaponBase* WeaponToToggle = GetCharacterCurrentEquippedWeapon();

		check(WeaponToToggle);

		if (bShouldEnable)
		{
			WeaponToToggle->GetWeaponCollisionBox()->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
		}
		else
		{
			WeaponToToggle->GetWeaponCollisionBox()->SetCollisionEnabled(ECollisionEnabled::NoCollision);

			OverlappedActors.Empty(); // 콜리전 비활성화 시, Overlap된 Actor 목록 비우기
		}
		
	}
}

// 자식 CombatComponent에서 구현
void UPawnCombatComponent::OnHitTargetActor(AActor* HitActor)
{
}

void UPawnCombatComponent::OnWeaponPulledFromTargetActor(AActor* InteractedActor)
{
}

델리게이트 BroadCasting 되었을 때 실행할 함수 바인딩을 하였고, 콜리전 비활성화 된 경우엔 Overlap된 Actor List 초기화하도록 구현하였다.

✔️ HeroCombatComponent

HeroCombatComponent.h

#pragma once

#include "CoreMinimal.h"
#include "Components/Combat/PawnCombatComponent.h"
#include "HeroCombatComponent.generated.h"

class AWarriorHeroWeapon;

UCLASS()
class RPG_API UHeroCombatComponent : public UPawnCombatComponent
{
	GENERATED_BODY()

public:
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	AWarriorHeroWeapon* GetHeroCarriedWeaponByTag(FGameplayTag InWeaponTag) const;
	
    // Delegate BroadCasting 되었을 때 호출되는 함수 선언 및 재정의
	virtual void OnHitTargetActor(AActor* HitActor) override;
	virtual void OnWeaponPulledFromTargetActor(AActor* InteractedActor) override;

};

HeroCombatComponent.cpp

#include "Components/Combat/HeroCombatComponent.h"
#include "Items/Weapons/WarriorHeroWeapon.h"
#include "AbilitySystemBlueprintLibrary.h"
#include "RPGGameplayTags.h"

AWarriorHeroWeapon* UHeroCombatComponent::GetHeroCarriedWeaponByTag(FGameplayTag InWeaponTag) const
{
   return Cast<AWarriorHeroWeapon>(GetCharacterCarriedWeaponByTag(InWeaponTag));
}

void UHeroCombatComponent::OnHitTargetActor(AActor* HitActor)
{
	// 이미 오버랩 된 객체라면 return
	if (OverlappedActors.Contains(HitActor))
	{
		return;
	}
	
    // 오버랩 액터 리스트에 추가
	OverlappedActors.AddUnique(HitActor); 
	
    // 공격자의 ASC로 GameplayEvent 전송
	FGameplayEventData Data;
	Data.Instigator = GetOwningPawn();
	Data.Target = HitActor;

	UAbilitySystemBlueprintLibrary::SendGameplayEventToActor(
		GetOwningPawn(),
		RPGGameplayTags::Shared_Event_MeleeHit,
		Data
	);
}

void UHeroCombatComponent::OnWeaponPulledFromTargetActor(AActor* InteractedActor)
{

}

피격된 대상의 정보를 공격자의 ASC로 전송하고, ASC에 등록된 Ability 중에서 해당 Event Tag를 트리거로 받을 수 있다.
이때 GameplayEventData로 공격 주체 및 피격 대상을 확인할 수 있다.

✔️ Light / Heavy Attack Ability 로직 수정

1. 공격 Ability에서 PlayMontage 노드가 실행되기 직전에, 현재의 ComboCount를 캐싱
2. 공격 Montage가 재생되었을 때, BoxCollision에 Hit된 객체가 있다면 "Shared.Event.MeleeHit" 태그로 이벤트 수신
3. 이벤트를 수신 받았다면 Hit된 대상을 로그로 출력

✔️ Attack 관련 AnimMontage 설정

모든 Melee Attack 관련 Montage에 적절하게 ANS_ToggleWeaponCollision을 설정해준다.

피격 처리된 객체 정보 수신 테스트

Heavy Attack_1에 피격 처리된 대상들을 확인할 수 있게 되었다.
이제 이 피격 대상들에게 Gameplay Effect를 적용해서 데미지 처리를 진행하도록 한다.

GAS_11_Attribute와 GameplayEffect

동그래님 — Thu, 8 May 2025 23:29:23 +0900

캐릭터에 Attribute 부여

초기에 BaseCharacter 클래스를 구현할 때, AttributeSet을 만들어놨지만 아직 내부가 비어있는 상태이다.
당연히 BaseCharacter를 상속 받은 플레이어 캐릭터와 Enemy 캐릭터는 모두 AttributeSet을 가지고 있다.
이 Attribute Set은 플레이어나 적 캐릭터가 피해량, 체력, 분노, 쉴드 등을 수치적으로 계산하기 위해 필수적으로 필요하다.

✅ Attribute Set 정의

FGameplayAttributeData로 선언한 Attribute는 Getter/Setter/Init 함수가 있어야만 GAS 내부에서 올바르게 읽고 쓸 수 있다.
이를 매번 수동으로 작성하면 중복 코드가 많아지고 실수할 수 있는 위험도가 높아지므로 Epic에서 매크로 헬퍼 함수를 제공한다.
이를 사용해 RPGAttributeSet클래스를 구현하도록 한다.

✔️ RPGAttributeSet

RPGAttributeSet.h

#pragma once

#include "CoreMinimal.h"
#include "AttributeSet.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "RPGAttributeSet.generated.h"

#define ATTRIBUTE_ACCESSORS(ClassName, PropertyName) \
GAMEPLAYATTRIBUTE_PROPERTY_GETTER(ClassName, PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_GETTER(PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_SETTER(PropertyName) \
GAMEPLAYATTRIBUTE_VALUE_INITTER(PropertyName)

UCLASS()
class RPG_API URPGAttributeSet : public UAttributeSet
{
	GENERATED_BODY()
	
public:
	URPGAttributeSet();

	UPROPERTY(BlueprintReadOnly, Category = "Health")
	FGameplayAttributeData CurrentHealth;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, CurrentHealth)

	UPROPERTY(BlueprintReadOnly, Category = "Health")
	FGameplayAttributeData MaxHealth;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, MaxHealth)

	UPROPERTY(BlueprintReadOnly, Category = "Rage")
	FGameplayAttributeData CurrentRage;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, CurrentRage)

	UPROPERTY(BlueprintReadOnly, Category = "Rage")
	FGameplayAttributeData MaxRage;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, MaxRage)

	UPROPERTY(BlueprintReadOnly, Category = "Damage")
	FGameplayAttributeData AttackPower;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, AttackPower)

	UPROPERTY(BlueprintReadOnly, Category = "Damage")
	FGameplayAttributeData DefensePower;
	ATTRIBUTE_ACCESSORS(URPGAttributeSet, DefensePower)
};

RPGAttributeSet.cpp

#include "AbilitySystem/RPGAttributeSet.h"

URPGAttributeSet::URPGAttributeSet()
{
	InitCurrentHealth(1.0f);
	InitMaxHealth(1.0f);
	InitCurrentRage(1.0f);
	InitMaxRage(1.0f);
	InitAttackPower(1.0f);
	InitDefensePower(1.0f);
}

Attribute 설정 확인

'~' 물결 키 버튼을 눌러 커멘드 창에 "showdebug AbilitySystem"을 입력하면, 다음과 같이 Ability System 디버그 UI가 보여진다.
앞서 설정했던 속성들이 보여지고, 생성자에서 Default값으로 1을 준 것 그대로 적용되어있는 것을 확인할 수 있다.

Gameplay Effect 생성

에디터에서 "GameplayEffect"를 상속 받는 BP 클래스를 생성하고 "GE_Hero_StartUp"이라고 명명한다.

✅ GameEffect_StartUp 데이터 설정

Duration Policy

Instant: 즉시 적용되고 바로 사라짐(초기 체력 100 세팅 등)
Infinite: 지속 효과, 수동으로 제거 전까지 유지됨(버프, 디버프 등)
Has Duration: 일정 시간 동안 유지되며 시간이 지나면 자동 종료(10초 동안 공격력 증가 등)

지속시간 정책을 의미하며, 현재는 초기 데이터 셋업이기 때문에 Instant로 적용한다.

Modifier Operation

FinalValue = ((BaseValue + AdditiveModifiers) * MultiplicativeModifiers) + PostMultiplicativeModifiers

GAS의 Attribute는 내부적으로 위와 같이 계산된다.

Add(Base): BaseValue에 더하는 값(기본 스텟 보정 등)
Multiply(Additive): BaseValue + Additive 값에 곱해지는 값(버프/디버프 등)
Divide(Additive): BaseValue + Additive 값에 나눠지는 값
Multiply(Compound): 누적 곱셈(여러 개의 계수가 각각 순차적으로 곱셈을 적용, 여러 버프 누적해서 적용 등)
Add(Final): PostMultiplicativeModifiers 단계 즉, 최종 결과에 더하는 값(회복량 보정 등)
Override: BaseValue 교체(기존 값 완전히 덮어씌움)

초기 값을 설정하는 것이기 때문에, Override로 설정한다.

Magnitude Calculation Type

Scalable Float: 하드코딩된 값 또는 Curve Table 기반으로 값을 계산
Attribute Based: 다른 속성 값 기반으로 계산(MaxHealth 기준으로 CurrentHealth 설정 등)
Custom Calculation Class: C++ 또는 Blueprint로 만든 커스텀 계산 로직 사용
SetByCaller: 능력 사용자가 값을 실시간으로 전달(탄환 피해량을 발사 시점에 결정 등)

Scalable Float로 설정 후, Curve Table 기반으로 값을 계산할 것이다.

Curve Table 생성 및 설정

Linear: 두 키 사이를 직선(선형)으로 보간한다. 부드럽고 자연스러운 증가곡선으로 가장 일반적이다.
Constant: 정수 간 값 사이의 보간 없이 해당 키의 값만 사용한다(1.0~2.9까지는 Level 1 값 그대로, 3.0이되면 Level 3 값으로 점프하는 등)
Cubic: 삼차 곡선(Cubic Hermite) 보간으로, 더 부드럽고 곡선 형태가 강하다(캐릭터 성장곡선, 이동속도 감속,가속 등 부드러운 곡선 형태가 중요한 경우 등)

GAS의 ScalableFloat에서 Curve Table을 사용할 때, 레벨 기반 스텟 스케일링을 하기 위해 Linear가 가장 많이 사용된다.
따라서 Linear로 설정해준다.

다음과 같이 Curve Table를 작성해주고, "GE_StartUp"에서 바인딩 해준다.

MaxHealth, MaxRage, AttackPower, DefensePower 속성 설정을 한다.

✅ GameEffect_Static 데이터 설정

"GE_Hero_StartUp"에서 캐릭터의 MaxHealth, MaxRange, Attack, Defense 등을 Curve Table 기반으로 설정하였다.
"GE_Static" 클래스를 만들어서 설정된 StartUp 데이터를 기반으로 현재 값을 계산해, CurrentHealth, CurrentRage등에 설정한다.

이번에도 "GameplayEffect"를 상속받는 "GE_Hero_Static" 이름의 클래스를 생성한다.

다음과 같이 CurrentHealth와 CurrentRage를 설정해준다.

Hero에 Gameplay Effect로 초기 Attribute 값 설정

Gameplay Effect를 적용하기에 가장 적합한 지점은 플레이어와 적 모두 시작 데이터를 구성하기 때문에 DataAsset_StartUpDataBase 클래스이다.

✅ 시작 데이터에 Gameplay Effect 저장

DataAsset_StartUpDataBase.h

#pragma once

#include "CoreMinimal.h"
#include "Engine/DataAsset.h"
#include "DataAsset_StartUpDataBase.generated.h"

class URPGGameplayAbility;
class URPGAbilitySystemComponent;
class UGameplayEffect;

UCLASS()
class RPG_API UDataAsset_StartUpDataBase : public UDataAsset
{
	GENERATED_BODY()
	
public:
	// 캐릭터(플레이어/적)의 ASC에 초기 능력을 부여
	virtual void GiveToAbilitySystemComponent(URPGAbilitySystemComponent* InRPG_ASC, int32 ApplyLevel = 1);

protected:
	UPROPERTY(EditDefaultsOnly, Category = "StartUpData")
	TArray<TSubclassOf<URPGGameplayAbility>> ActivateOnGivenAbilites;

	UPROPERTY(EditDefaultsOnly, Category = "StartUpData")
	TArray<TSubclassOf<URPGGameplayAbility>> ReactiveAbilites;

	// GameplayEffect 데이터들
	UPROPERTY(EditDefaultsOnly, Category = "StartUpData")
	TArray<TSubclassOf<UGameplayEffect>> StartUpGameplayEffects;

	void GrantAbilites(
		const TArray<TSubclassOf<URPGGameplayAbility>>& InAbilitesToGive,
		URPGAbilitySystemComponent* InRPG_ASC, int32 ApplyLevel = 1
	);
};

DataAsset_StartUpDataBase.cpp

#include "DataAssets/StartUpData/DataAsset_StartUpDataBase.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "AbilitySystem/Abilities/RPGGameplayAbility.h"

void UDataAsset_StartUpDataBase::GiveToAbilitySystemComponent(URPGAbilitySystemComponent* InRPG_ASC, int32 ApplyLevel)
{
	check(InRPG_ASC);

	GrantAbilites(ActivateOnGivenAbilites, InRPG_ASC, ApplyLevel);
	GrantAbilites(ReactiveAbilites, InRPG_ASC, ApplyLevel);

	// GameplayEffect들을 자기 자신에게 적용
	if (!StartUpGameplayEffects.IsEmpty())
	{
		for (const TSubclassOf<UGameplayEffect>& EffectClass : StartUpGameplayEffects)
		{
			if (!EffectClass) continue;

			UGameplayEffect* EffectCDL = EffectClass->GetDefaultObject<UGameplayEffect>();
			InRPG_ASC->ApplyGameplayEffectToSelf(
				EffectCDL,
				ApplyLevel,
				InRPG_ASC->MakeEffectContext()
			);
		}
	}
}

void UDataAsset_StartUpDataBase::GrantAbilites(const TArray<TSubclassOf<URPGGameplayAbility>>& InAbilitesToGive, URPGAbilitySystemComponent* InRPG_ASC, int32 ApplyLevel)
{
	if (InAbilitesToGive.IsEmpty())
	{
		return;
	}

	for (const TSubclassOf<URPGGameplayAbility>& Ability : InAbilitesToGive)
	{
		if (!Ability) continue;

		FGameplayAbilitySpec AbilitySpec(Ability); // 어빌리티 클래스 지정
		AbilitySpec.SourceObject = InRPG_ASC->GetAvatarActor(); // 출처 지정
		AbilitySpec.Level = ApplyLevel; // 레벨 설정

		InRPG_ASC->GiveAbility(AbilitySpec); // ASC에 등록
	}
}

✅ DA_Hero에 GE 할당

에디터로 돌아와 "DA_Hero"를 살펴보면 방금 추가했던 GameEffect 저장할 배열이 생겨난 것을 확인할 수 있다.
앞서 만들었던 "GE_Hero_StartUp"과 "GE_Hero_Static" Effect를 할당해준다.
이때 중요한 것은 "StartUp"이 앞 인덱스에 와있어야 최대 체력을 기준으로 "Static"에 현재 체력을 저장할 수 있기 때문에 순서를 유의해야한다.

GameplayEffect로 Attribute 값 초기화 결과

콘솔에 "showdebug AbilitySystem"을 입력하고 디버그 창을 띄워서 살펴보면 Curve Table의 Level1에서 설정한 초기 값들이 정상적으로 입력되어있는 것을 확인할 수 있다.

Enemy에 Gameplay Effect로 초기 Attribute 값 설정

플레이어에게 했던 것처럼 Enemy의 Attribute에 GE로 초기 데이터 셋업을 진행한다.

플레이어 CurveTable을 복사해서 "CT_GuardianStats"로 명명하고, Rage Attribute 만 빼주었다.

Guardian Enemy 전용 GE_StartUp을 생성하고 다음과 같이 설정한다.

GE_StartUp에서 설정한 MaxHealth 값을 가져와 현재 CurrentHealth값을 덮어씌우는 GameplayEffect를 만들었다.
모든 적이 공통으로 최대 체력 값으로 현재 체력으로 설정하는 것을 반복해야되기 때문에, "GE_Enemy_Static"으로 명명하여 공통으로 사용하는 GamplayEffect임을 명시해준다.

Guardian의 StartUp DataAsset에서 GameplayEffect를 할당해준다.

테스트 결과 / 디버그 HUD 오류

"showdebug AbilitySystem"으로 디버깅 UI를 생성하고 (PageUp/PageDown)을 입력하면 다른 대상의 정보를 확인할 수 있다.
Enemy의 정보를 확인해본 결과, CT에 있는 데이터와 디버그에 표시되는 Enemy의 스탯이 다르게 보여지는 문제가 생겼다.

Enemy의 올바른 속성 값을 표시하려면 DefaultGame.ini에서 설정을 해줘야한다.
그렇지 않으면 디버그 카드의 모든 속성에 대해 동일한 속성값만 표시될 것이다.

DefaultGame.ini 파일 수정

[/Script/GameplayAbilities.AbilitySystemGlobals]
bUseDebugTargetFromHud = true
우측과 같이 위의 두줄을 포함해준다.

테스트 최종 결과

ini 파일을 수정한 후 다시 테스트를 해보면 정상적으로 Enemy의 Stat이 올바르게 표시되는 것을 확인할 수 있다.

GAS_10_Enemy 클래스 생성

동그래님 — Thu, 8 May 2025 16:17:54 +0900

적 캐릭터 생성

✅ Enemy 관련 클래스 생성

Enemy 관련 (Character, Start Up Data, Gameplay Ability, Combat Component) 클래스를 생성해준다.

✅ Enemy 관련 클래스 구현

EnemyCharacter 클래스

EnemyCharacter.h

#pragma once

#include "CoreMinimal.h"
#include "Characters/RPGBaseCharacter.h"
#include "RPGEnemyCharacter.generated.h"

class UEnemyCombatComponent;

UCLASS()
class RPG_API ARPGEnemyCharacter : public ARPGBaseCharacter
{
	GENERATED_BODY()
	
public:
	ARPGEnemyCharacter();

protected:
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Combat")
	TObjectPtr<UEnemyCombatComponent> EnemyCombatComponent;

public:
	FORCEINLINE UEnemyCombatComponent* GetEnemyCombatComponent() const { return EnemyCombatComponent; }
};

EnemyCharacter.cpp

#include "Characters/RPGEnemyCharacter.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Components/Combat/EnemyCombatComponent.h"

ARPGEnemyCharacter::ARPGEnemyCharacter()
{
	AutoPossessAI = EAutoPossessAI::PlacedInWorldOrSpawned;

	bUseControllerRotationPitch = false;
	bUseControllerRotationRoll = false;
	bUseControllerRotationYaw = false;

	GetCharacterMovement()->bUseControllerDesiredRotation = false;
	GetCharacterMovement()->bOrientRotationToMovement = true;
	GetCharacterMovement()->RotationRate = FRotator(0.0f, 180.0f, 0.0f);
	GetCharacterMovement()->MaxWalkSpeed = 300.0f;
	GetCharacterMovement()->BrakingDecelerationWalking = 1000.0f;

	EnemyCombatComponent = CreateDefaultSubobject<UEnemyCombatComponent>(TEXT("EnemyCombatComponent"));
}

EnemyGameplayAbility 클래스

EnemyGameplayAbility.h

#pragma once

#include "CoreMinimal.h"
#include "AbilitySystem/Abilities/RPGGameplayAbility.h"
#include "RPGEnemyGameplayAbility.generated.h"

class ARPGEnemyCharacter;
class UEnemyCombatComponent;

UCLASS()
class RPG_API URPGEnemyGameplayAbility : public URPGGameplayAbility
{
	GENERATED_BODY()
	
public:
	// Enemy 캐릭터 반환
	UFUNCTION(BlueprintPure, Category = "RPG|Ability")
	ARPGEnemyCharacter* GetEnemyCharacterFromActorInfo();

	// Enemy CombatComponent 반환
	UFUNCTION(BlueprintPure, Category = "RPG|Ability")
	UEnemyCombatComponent* GetEnemyCombatComponentFromActorInfo();

private:
	TWeakObjectPtr<ARPGEnemyCharacter> CachedRPGEnemyCharacter;
};

EnemyGameplayAbility.cpp

#include "AbilitySystem/Abilities/RPGEnemyGameplayAbility.h"
#include "Characters/RPGEnemyCharacter.h"

ARPGEnemyCharacter* URPGEnemyGameplayAbility::GetEnemyCharacterFromActorInfo()
{
	if (!CachedRPGEnemyCharacter.IsValid())
	{
		CachedRPGEnemyCharacter = Cast<ARPGEnemyCharacter>(CurrentActorInfo->AvatarActor);
	}

	return CachedRPGEnemyCharacter.IsValid() ? CachedRPGEnemyCharacter.Get() : nullptr;
}

UEnemyCombatComponent* URPGEnemyGameplayAbility::GetEnemyCombatComponentFromActorInfo()
{
	return GetEnemyCharacterFromActorInfo()->GetEnemyCombatComponent();
}

우선 EnemyCharacter 클래스와 EnemyGameplayAbility 클래스에 기본적인 구현을 진행한다.

에디터로 돌아와 "RPGEnemyCharacter" C++ 클래스를 상속 받는 BP클래스를 생성한다.
"BP_EnemyCharacter_Base"라 명명하고, 이 클래스는 모든 Enemy 클래스의 최상위 부모 클래스가 된다.

다음과 같은 상속 구조로 Enemy Character BP 클래스를 생성한다.

✅ Enemy / ABP 세팅

최하단 자식 클래스인 "BP_Gruntling_Guardian" 클래스에 Mesh와 Collision 설정을 적절히 해준다.

Enemy의 애니메이션의 경우 대부분 다 비슷하기 때문에 각각 개별적으로 만들어 주지 않고, Template을 만들어준다.
Template ABP의 경우 스켈레톤을 할당할 필요는 없지만 부모 클래스는 지정해야한다. 이전에 만들어두었던 Character AnimIntacne클래스로 설정한다.
이전에 부모 클래스 Character Anim Instance에 만들어 두었던 Data들을 확인할 수 있다.

다음과 같이 Enemy 전용 ABP Template클래스에 기본적인 로직을 구현한다.

해당 ABP의 자식 클래스를 생성하고 만들고자 하는 Enemy Skeleton을 지정한다.

자식 클래스에서 BlendSpace 1D를 생성해 할당하고, Enemy Character 클래스에 해당 ABP를 할당해준다.

Enemy에 Ability 부여

✅ Enemy / StartUpData 세팅

기존에 플레이어 캐릭터도 "DataAsset_HeroStartUpData" 클래스를 상속 받은 "DA_Hero" 클래스를 만들어 Ability들을 저장하고 부여했었다.
Enemy 캐릭터도 마찬가지로 StartUpData를 구성해준다.

DataAsset_EnemyStartUpData.h

#pragma once

#include "CoreMinimal.h"
#include "DataAssets/StartUpData/DataAsset_StartUpDataBase.h"
#include "DataAsset_EnemyStartUpData.generated.h"

class URPGEnemyGameplayAbility;

UCLASS()
class RPG_API UDataAsset_EnemyStartUpData : public UDataAsset_StartUpDataBase
{
	GENERATED_BODY()

public:
	// Enemy 캐릭터의 ASC에 초기 능력을 부여
	virtual void GiveToAbilitySystemComponent(URPGAbilitySystemComponent* InRPG_ASC, int32 ApplyLevel = 1) override;

private:
	UPROPERTY(EditDefaultsOnly, Category = "StartUpData")
	TArray<TSubclassOf<URPGEnemyGameplayAbility>> EnemyCombatAbilities;
};

Enemy의 경우 Input이 따로 없기 때문에, 바로 TArray<TSubclassOf<URPGGameplayAbility>> 타입으로 배열을 선언해주었다.

DataAsset_EnemyStartUpData.cpp

#include "DataAssets/StartUpData/DataAsset_EnemyStartUpData.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "AbilitySystem/Abilities/RPGEnemyGameplayAbility.h"

void UDataAsset_EnemyStartUpData::GiveToAbilitySystemComponent(URPGAbilitySystemComponent* InRPG_ASC, int32 ApplyLevel)
{
	Super::GiveToAbilitySystemComponent(InRPG_ASC, ApplyLevel);

	if (!EnemyCombatAbilities.IsEmpty())
	{
		for (const TSubclassOf<URPGEnemyGameplayAbility>& AbilityClass : EnemyCombatAbilities)
		{
			if (!AbilityClass) continue;

			FGameplayAbilitySpec AbilitySpec(AbilityClass);
			AbilitySpec.SourceObject = InRPG_ASC->GetAvatarActor();
			AbilitySpec.Level = ApplyLevel;

			InRPG_ASC->GiveAbility(AbilitySpec);
		}
	}
}

에디터에서 해당 클래스를 상속 받은 "DA_Guardian" 클래스를 생성해준다.
내부를 보면 Enemy Combat Abilities 배열이 추가되어있는 것을 확인할 수 있다.

✅ Enemy / StartUpData 로딩

이전에 플레이어 캐릭터는 PossessedBy 시점에, 데이터를 동기 로딩하였었다.
현재 이 프로젝트는 싱글 플레이로, 플레이어 캐릭터 인스턴스가 1개임이 확정적이기 때문에 즉시 사용가능하도록 하기 위함이었다.
하지만 AI의 경우 어느정도의 인스턴스가 생성될지 모르고, 대량의 로딩이 한꺼번에 이루어질 경우 hitch(게임이 멈추고나 끊김 현상)가 발생할 수 있어 비동기 로딩으로 진행하는 것이 안정적이다.
따라서 특정 시점에 BackGround에서 병렬적으로 로딩할 수 있도록 한다.

RPGEnemyCharacter.h

#pragma once

#include "CoreMinimal.h"
#include "Characters/RPGBaseCharacter.h"
#include "RPGEnemyCharacter.generated.h"

class UEnemyCombatComponent;

UCLASS()
class RPG_API ARPGEnemyCharacter : public ARPGBaseCharacter
{
	GENERATED_BODY()
	
public:
	ARPGEnemyCharacter();

protected:
	//~ Begin APawn Interface
	virtual void PossessedBy(AController* NewController) override;
	//~ End APawn Interface

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Combat")
	TObjectPtr<UEnemyCombatComponent> EnemyCombatComponent;
	
private:
	void InitEnemyStartUpData();

public:
	FORCEINLINE UEnemyCombatComponent* GetEnemyCombatComponent() const { return EnemyCombatComponent; }
};

RPGEnemyCharacter.cpp

#include "Characters/RPGEnemyCharacter.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Components/Combat/EnemyCombatComponent.h"
#include "Engine/AssetManager.h"
#include "DataAssets/StartUpData/DataAsset_EnemyStartUpData.h"

#include "WarriorDebugHelper.h"

ARPGEnemyCharacter::ARPGEnemyCharacter()
{
	AutoPossessAI = EAutoPossessAI::PlacedInWorldOrSpawned;

	bUseControllerRotationPitch = false;
	bUseControllerRotationRoll = false;
	bUseControllerRotationYaw = false;

	GetCharacterMovement()->bUseControllerDesiredRotation = false;
	GetCharacterMovement()->bOrientRotationToMovement = true;
	GetCharacterMovement()->RotationRate = FRotator(0.0f, 180.0f, 0.0f);
	GetCharacterMovement()->MaxWalkSpeed = 300.0f;
	GetCharacterMovement()->BrakingDecelerationWalking = 1000.0f;

	EnemyCombatComponent = CreateDefaultSubobject<UEnemyCombatComponent>(TEXT("EnemyCombatComponent"));
}

void ARPGEnemyCharacter::PossessedBy(AController* NewController)
{
	Super::PossessedBy(NewController);

	InitEnemyStartUpData();
}

void ARPGEnemyCharacter::InitEnemyStartUpData()
{
	if (CharacterStartUpData.IsNull()) return;

	UAssetManager::GetStreamableManager().RequestAsyncLoad( // AssetManager를 통해 비동기 로딩 요청
		CharacterStartUpData.ToSoftObjectPath(),			// 불러올 자산의 경로
		FStreamableDelegate::CreateLambda(					// 로딩 완료 시 실행할 콜백 함수
			[this]()
			{
				if (UDataAsset_StartUpDataBase* LoadedData = CharacterStartUpData.Get())
				{
					LoadedData->GiveToAbilitySystemComponent(RPGAbilitySystemComponent);

					Debug::Print(TEXT("Enemy Start up Data Loaded"), FColor::Green);
				}
			}
		)
	);
}

컴파일 후, 에디터로 돌아와서 Enemy Character 클래스에 StartUpData를 할당해주었다.
플레이 했을 때 정상적으로 LoadData가 연결된 것을 확인할 수 있었다.

다만 현재 Possessed By 시점에 비동기 로딩을 하게끔 구현하였는데, Editor 환경에서 월드에 미리 배치 되어있는 적의 경우 StartUpData가 미리 로딩되어있을 수 있어서 정상적으로 비동기 로딩이 되었을 수 있다.
캐릭터 클래스에서 Soft Reference로 StartUpData를 가지고 있기 때문에 런타임에 Spawn된 적의 경우나 패키징된 상황에서 Possessed By 시점에 Data가 메모리에 올라와 있지 않아, 정상적으로 Ability가 등록 되지 않을 경우가 발생할 수 있다.

따라서 테스트를 해보고 이상이 있다면, BeginPlay에서 ㅁ

✅ Enemy / StartUpData 데이터 할당

✔️ Enemy Weapon Tag 추가

RPGGameplayTags.h

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** Input Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Move);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Look);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_EquipAxe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_UnequipAxe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_LightAttack_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_HeavyAttack_Axe);

	/** Player Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Equip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Unequip_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Attack_Light_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Attack_Heavy_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Weapon_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Equip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Unequip_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Status_JumpToFinisher);

	/** Enemy Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Enemy_Weapon); // Enemy 무기 태그 추가
}

RPGGameplayTags.CPP

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** Input Tags */
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Move, "InputTag.Move");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Look, "InputTag.Look");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_EquipAxe, "InputTag.EquipAxe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_UnequipAxe, "InputTag.UnequipAxe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_LightAttack_Axe, "InputTag.LightAttack.Axe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_HeavyAttack_Axe, "InputTag.HeavyAttack.Axe");

	/** Player Tags */
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Equip_Axe, "Player.Ability.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Unequip_Axe, "Player.Ability.Unequip.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Attack_Light_Axe, "Player.Ability.Attack.Light.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Attack_Heavy_Axe, "Player.Ability.Attack.Heavy.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Weapon_Axe, "Player.Weapon.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Equip_Axe, "Player.Event.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Unequip_Axe, "Player.Event.Unequip.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Status_JumpToFinisher, "Player.Status.JumpToFinisher");

	/** Enemy Tags */
	UE_DEFINE_GAMEPLAY_TAG(Enemy_Weapon, "Enemy.Weapon"); // Enemy 무기 태그 추가

}

✔️ Enemy 무기 클래스 생성

"RPGWeaponBase"를 상속 받아 "BP_Enemy_Weapon_Base" 클래스를 생성한 뒤, 이를 상속 받는 가디언 전용 무기 클래스를 생성한다.

✔️ Skeletal Mesh에서 Weapon Socket 생성

✔️ 무기 스폰 Ability 생성 및 데이터 할당

이전에 캐릭터 스폰 시, 무기를 스폰해 지정한 Mesh Socket에 부착하는 GameplayAbility를 만들었었다.
이를 상속받는 "GA_Guardian_SpawnWeapon" 어빌리티를 생성한다.
앞서 만들었던 무기 클래스, Socket Name, Weapon Tag, 장착 무기로 등록(true) 설정을 진행한다.

✔️ 캐릭터가 가지고 있는 StartUpData에 무기 스폰 Ability 등록

캐릭터 클래스에 할당되어있는 "DA_Guardian"을 더블클릭 후, 방금 만든 무기 스폰 Ability를 할당해준다.

Enemy 무기 스폰 Ability 동작 테스트

게임을 시작하면, 성공적으로 Enemy의 StartUpData가 비동기 로딩 되고, 내부 데이터에 GameAbility가 등록되며 자동으로 실행되어 무기가 정상적으로 스폰되었다.

GAS_09_무기 공격 애니메이션 구현

동그래님 — Wed, 7 May 2025 20:44:46 +0900

Light Attack 콤보 구현

도끼 장착시 강공격/약공격 어빌리티를 추가하여 콤보 시스템 구현을 준비한다.

1. InputTag / AbilityTag 설정
2. GA_LightAttack 능력 생성 및 Tag Setting
3. InputAction 생성하고 IMC_Axe에 바인딩
4. DA_InputConfig에 InputAction과 Tag 바인딩
5. 무기 클래스에 GA와 InputTag 바인딩
6. 무기 장착 / 해제 Ability에 Attack Tag 블로킹 처리

✅ Light Attack_Input 및 Ability 세팅

RPGGameplayTags.h

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** Input Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Move);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Look);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_EquipAxe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_UnequipAxe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_LightAttack_Axe); // 공격 Input 추가
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_HeavyAttack_Axe); // 공격 Input 추가

	/** Player Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Equip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Unequip_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Attack_Light_Axe); // 공격 Ability 추가
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Attack_Heavy_Axe); // 공격 Ability 추가

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Weapon_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Equip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Unequip_Axe);
}

RPGGameplayTags.cpp

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** Input Tags */
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Move, "InputTag.Move");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Look, "InputTag.Look");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_EquipAxe, "InputTag.EquipAxe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_UnequipAxe, "InputTag.UnequipAxe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_LightAttack_Axe, "InputTag.LightAttack.Axe"); // 공격 Input 추가
	UE_DEFINE_GAMEPLAY_TAG(InputTag_HeavyAttack_Axe, "InputTag.HeavyAttack.Axe"); // 공격 Input 추가

	/** Player Tags */
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Equip_Axe, "Player.Ability.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Unequip_Axe, "Player.Ability.Unequip.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Attack_Light_Axe, "Player.Ability.Attack.Light.Axe"); // 공격 Ability 추가
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Attack_Heavy_Axe, "Player.Ability.Attack.Heavy.Axe"); // 공격 Ability 추가

	UE_DEFINE_GAMEPLAY_TAG(Player_Weapon_Axe, "Player.Weapon.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Equip_Axe, "Player.Event.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Unequip_Axe, "Player.Event.Unequip.Axe");
}

WarriorHeroGameplayAbility를 상속 받는 "GA_Hero_LightAttackMaster" 이름으로 약공격 Ability 부모클래스를 만들고, 이를 상속 받는 "GA_Hero_LightAttack_Axe" 클래스를 생성해주었다.
LightAttackMaster에 Tag Setting 진행.

InputAction_LightAttackAxe를 생성하고, Axe 무기 전용 IMC에 바인딩

InputConfig에 "Light Attack" 관련 InputTag - InputAction 바인딩

무기 클래스에 InputTag와 GA 바인딩

"GA_Hero_EquipAxe", "GA_Hero_UnequipAxe" Ability 클래스에서 장비 착용 및 장비 해제 Ability가 활성화 되는 동안 공격을 하지 못하도록 Block 처리 해주었다.

✅ Combo Attack 로직

✔️ Instancing Policy

본격적으로 콤보 로직을 구현하기 GameAbility의 Instancing Policy(인스턴스화 정책)에 대해 알고 넘어가야 한다.
콤보 시스템에서 애니메이션을 독립적으로 만들려면 GA에 Instancing Policy 설정을 해줘야한다.

Instanced Per Execution:
- 어빌리티 실행 시, 항상 새 인스턴스 생성
- 변수는 항상 기본값으로 초기화됨
- 재사용 안 함 → 메모리/성능 손해
- Fire / Dash / 짧은 효과 등 매번 초기화가 필요한 Ability에 적합
Instanced Per Actor:
- 어빌리티 인스턴스를 처음 1회만 생성
- 이후 계속 재사용
- 내부 상태 저장 가능
- Combo / Charge / 지속 효과 등 상태 저장이 필요한 Ability에 적합
Non Instanced:
- 인스턴스 생성 X
- 로직은 전부 C++에서만 구현 가능
- Blueprint에서는 변수 저장 불가
- 성능이 제일 좋지만 유연성은 적음
- 단순 / 빠름/ 최적화 우선이며 Blueprint 사용하지 않아도 될 때 적합

현재 콤보 어택을 구현하고 있는 LightAttack 부모 클래스에 Instancing Policy를 "Instanced Per Actor"로 설정 해준다.
이유는 내부에 Combo Attack Count라는 int 변수를 두고 공격을 실행 했을 때마다 Count 값을 증가시키고 현재 Count 값에 맞는 Anim Montage를 재생시켜야하기 때문이다.

"GA_Hero_LightAttackMontage"에 콤보 어택 로직을 다음과 같이 작성한다.
TMap을 사용해서 각 인덱스마다 Anim Montage를 저장해놓고 현재 Combo Count에 맞게 애니메이션을 재생시켜준다.

Combo 로직을 구현한 "GA_Hero_LightAttackMater" 클래스를 상속 받은 "GA_Hero_LightAttack_Axe"클래스에서 4개의 애니메이션을 저장할 준비를 한다.

이전에 장비를 장착/탈착 했던 애니메이션들은 이동하면서 해당 동작이 가능했어야 해서 UpperBody 슬롯에서만 재생되도록 구현하다보니 Root Motion을 비활성화 했어야 했다.
하지만 현재는 하체까지 공격하는 애니메이션이 적용되도록 할 것이기 때문에, 4가지 애니메이션 모두 Root Motion 활성화를 체크하도록 한다.

4개의 애니메이션 몽타주를 생성하고, 콤보 어택에 사용되기에 재생속도가 느려서 Rate Scale을 2.0으로 빠르게 설정해주었고, "FullBody"slot을 생성하여 적용시켜주었다.
1~3번 애니메이션은 2.0의 속도, 마지막 4번 애니메이션은 1.5로 앞 동작보다는 느리게 해주었다.

다시 "GA_Hero_LightAttack"에 돌아와 Map컨테이너에 몽타주들을 바인딩한다.

메인 ABP클래스인 "ABP_Hero" AnimGraph에서 방금 생성했던 FullBody Slot을 최종 Output Pose 핀 앞에 연결해준다.

Light 콤보 어택 테스트

마우스 클릭을 천천히 하면 Montage_1만 나오는 모습을 볼 수 있고, 연속적으로 빠르게 누르면 Montage_1~4번까지 정상적으로 잘 나오는 모습을 확인할 수 있었다.

Heavy Attack 구현

Light Attack을 구현하면서 Heavy Attack에 대한 GameplayTag도 선언하였었다.
앞서 Light Attack Ability를 인풋을 등록하고 캐릭터에 능력을 부여하는 것까지의 과정을 똑같이 Heavy Attack Ability 빠르게 적용시킨다.

1. GameplayAbility 생성 후 Tag Setting
2. InputAction 생성 후 IMC에 바인딩
3. DA_InputConfig에 InputTag - InputAction 바인딩
4. Weapon Class에 InputTag - GA 바인딩

✅ Heavy Attack Ability 생성 및 등록

GameplayAbility 생성 후 Tag Setting

InputAction 생성 후 IMC에 바인딩

DA_InputConfig에 InputTag - InputAction 바인딩

Weapon Class에 InputTag - GA 바인딩

✅ Heavy Attack Ability 기능 구현

앞서 Light Attack Ability 로직도 연속적으로 공격을 입력하면 Combo Attack이 나오도록 구현하였다.
Heavy Attack Ability도 마찬가지로 연속적으로 빠르게 입력을 하면 Combo Attack이 되도록 구현하도록 한다.

"GA_Hero_HeavyAttackMaster" 부모 클래스에 해당 로직을 작성한다. 로직은 LightAttack과 동일하다.

"AttackMontagesMap" - Integer를 Key로, AnimMonstage Object Class를 Value로 가지고 있다.
"HeavyAttackComboCount" - Default Value로 1을 가지고 있고 연타하면 최대 Map의 크기 만큼 1씩 증가한다.
"ComboCountResetTimerHandle" - 0.3초 이내에 추가 입력이 들어오지 않으면 ComboCount를 Reset 시켜주는데, 이때 사용한 TimerHandle 캐싱

Heavy Attack 부모 클래스에선 Asset Tag를 "Player.Ability.Attack.Heavy" 까지만 설정하고 자식 클래스에서 세부 무기까지 포함해서 "Player.Ability.Attack.Heavy.Axe"로 설정할 것이다.
Combo Attack Count 변수가 계속 지속적으로 관리되어야 하기 때문에, "Instanced Per Actor" 정책으로 설정해주었다.
해당 설정들은 "GA_Hero_LightAttackMaster" 클래스와 동일하다.

"GA_Hero_HeavyAttackMaster"클래스를 상속받은 Ability 클래스에서 Map 컨테이너에 해당하는 몽타주를 넣어준다.
앞서 말했듯이 자식클래스에선 AssetTag를 Axe까지 붙혀주었고 Instancing Policy도 부모와 동일한지 확인해준다.

Light / Heavy 콤보 어택 테스트

무기를 장착하고, Light Attack(1~4) 그리고 Heavy Attack(1~2) 몽타주가 정상적으로 재생되는것을 확인할 수있다.

Light → Heavy(마지막 공격)으로 전환하는 Combo Attack 구현

현재 약공격은 4단계로 이루어져있고, 강공격은 2단계로 이루어져 있다.
약공격 3단계까지 수행한 후에 바로 강공격 2단계로 넘어갈 수 있도록 해서, 플레이어가 다른 공격 콤보 패턴을 사용할 수 있도록 해보려한다.

이를 위해선 LightAttack의 ComboCnt가 3단계 이후 라면 "JumpToFinisher"라는 GameplayTag를 캐릭터에 부여하고,
HeavyAttack Ability는 해당 태그가 존재한다면 현재 ComboCnt를 무시하고 즉시 HeavyAttack 2단계인 피니셔 동작을 실행할 수 있어야한다.
이후 피니셔 동작이 끝나면 태그를 제거하고 ComboCnt를 초기화 하도록 한다.

✅ GAS 기반 시스템 전용 Function Library 구현

GAS 시스템을 사용하다보면 ASC를 여러 클래스(Character, Ability 등)에서 가져와야 하는 경우가 있다.
그리고 현재 구현하는 상황처럼, 특정 Ability 활성화 중에 Tag를 부여하거나 제거해야할 일이 많이 생길 것이다.

이를 위해 코드 재사용성 증가와 로직 통일성, 블루프린트 로직 간결화 등의 이점을 가져가기 위해 Blueprint Function Library 클래스를 만들어 자주 사용되는 기능들을 구현할 것이다.

"Blueprint Function Library"를 상속 받는 C++클래스를 생성한다.

RPGFunctionLibrary.h

#pragma once

#include "CoreMinimal.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "GameplayTagContainer.h"
#include "RPGFunctionLibrary.generated.h"

class URPGAbilitySystemComponent;

UENUM()
enum class ERPGConfirmType : uint8
{
	Yes,
	No
};

UCLASS()
class RPG_API URPGFunctionLibrary : public UBlueprintFunctionLibrary
{
	GENERATED_BODY()
	
public:
	// Actor로부터 ASC 반환 함수
	static URPGAbilitySystemComponent* NativeGetRPGASC_FormActor(AActor* InActor);

	// ASC가 특정 Tag를 가지고 있는지 확인
	static bool NativeDoesActorHaveTag(AActor* InActor, FGameplayTag TagToCheck);

	// Actor에 Tag 추가
	UFUNCTION(BlueprintCallable, Category = "RPG|FunctionLibrary")
	static void AddGameplayTagToActorIfNone(AActor* InActor, FGameplayTag TagToAdd);

	// Actor에 Tag 제거
	UFUNCTION(BlueprintCallable, Category = "RPG|FunctionLibrary")
	static void RemoveGameplayTagFromActorIfFound(AActor* InActor, FGameplayTag TagToRemove);

	// Native 함수 사용해서 BP에서 Tag 가지고 있는지 여부를 Enum으로 반환(Branch 노드 사용 줄이기 위함)
	UFUNCTION(BlueprintCallable, Category = "RPG|FunctionLibrary", meta = (DisplayName = "Does Actor Have Tag", ExpandEnumAsExecs = "OutConfirmType"))
	static void BP_DoesActorHaveTag(AActor* InActor, FGameplayTag TagToCheck, ERPGConfirmType& OutConfirmType);

};

C++ 클래스 내부에서만 사용되는 함수 네이밍은 접두어로 Native로 구분해주었다.
"BP_DoesActorHaveTag" 함수의 경우 Enum을 BP에서 분기 OutPin으로 설정하여 Branch 노드를 사용하지 않아도 되어 블루프린트 로직을 간결하게 한다.

RPGFunctionLibrary.cpp

#include "RPGFunctionLibrary.h"
#include "AbilitySystemBlueprintLibrary.h"
#include "AbilitySystem/RPGAbilitySystemComponent.h"

URPGAbilitySystemComponent* URPGFunctionLibrary::NativeGetRPGASC_FormActor(AActor* InActor)
{
	check(InActor);
	
	return CastChecked<URPGAbilitySystemComponent>(UAbilitySystemBlueprintLibrary::GetAbilitySystemComponent(InActor));
}

bool URPGFunctionLibrary::NativeDoesActorHaveTag(AActor* InActor, FGameplayTag TagToCheck)
{
	URPGAbilitySystemComponent* ASC = NativeGetRPGASC_FormActor(InActor);

	return ASC->HasMatchingGameplayTag(TagToCheck);
}

void URPGFunctionLibrary::AddGameplayTagToActorIfNone(AActor* InActor, FGameplayTag TagToAdd)
{
	URPGAbilitySystemComponent* ASC = NativeGetRPGASC_FormActor(InActor);

	if (!ASC->HasMatchingGameplayTag(TagToAdd))
	{
		ASC->AddLooseGameplayTag(TagToAdd);
	}
}

void URPGFunctionLibrary::RemoveGameplayTagFromActorIfFound(AActor* InActor, FGameplayTag TagToRemove)
{
	URPGAbilitySystemComponent* ASC = NativeGetRPGASC_FormActor(InActor);

	if (ASC->HasMatchingGameplayTag(TagToRemove))
	{
		ASC->RemoveLooseGameplayTag(TagToRemove);
	}
}

void URPGFunctionLibrary::BP_DoesActorHaveTag(AActor* InActor, FGameplayTag TagToCheck, ERPGConfirmType& OutConfirmType)
{
	OutConfirmType = NativeDoesActorHaveTag(InActor, TagToCheck) ? ERPGConfirmType::Yes : ERPGConfirmType::No;
}

앞서 만든 함수들을 블루프린트 전역에서 사용할 수 있게 되었다.

✅ GAS 기반 시스템 전용 Function Library 구현

✔️ Gameplay Tag 추가

RPGGameplayTags.h

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** Input Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Move);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Look);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_EquipAxe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_UnequipAxe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_LightAttack_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_HeavyAttack_Axe);

	/** Player Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Equip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Unequip_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Attack_Light_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Attack_Heavy_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Weapon_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Equip_Axe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Unequip_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Status_JumpToFinisher); // 마지막 공격 전환 Tag 추가
}

RPGGameplayTags.cpp

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** Input Tags */
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Move, "InputTag.Move");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Look, "InputTag.Look");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_EquipAxe, "InputTag.EquipAxe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_UnequipAxe, "InputTag.UnequipAxe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_LightAttack_Axe, "InputTag.LightAttack.Axe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_HeavyAttack_Axe, "InputTag.HeavyAttack.Axe");

	/** Player Tags */
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Equip_Axe, "Player.Ability.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Unequip_Axe, "Player.Ability.Unequip.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Attack_Light_Axe, "Player.Ability.Attack.Light.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Attack_Heavy_Axe, "Player.Ability.Attack.Heavy.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Weapon_Axe, "Player.Weapon.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Equip_Axe, "Player.Event.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Unequip_Axe, "Player.Event.Unequip.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Status_JumpToFinisher, "Player.Status.JumpToFinisher"); // 마지막 공격 전환 Tag 추가

}

GA_Hero_LightAttackMaster

Light Attack Ability 로직을 다음과 같이 수정한다.

1. 현재 Combo Count가 마지막 전이라면(총 4개의 공격 콤보 중 3번째 공격까지 한 상황), 라이브러리 함수를 사용해서 Character에 Tag를 부여한다.
2. Combo Count가 Reset 될 때, 부여했던 Tag를 삭제한다.

GA_Hero_HeavyAttackMaster

1. Heavy Attack Ability가 활성화 되었을 때, 현재 Character에 마지막 공격으로 전환 Tag가 있는지 확인한다.
2. 만약 태그가 있다면 현재 Combo Count를 마지막 단계로 설정하고 해당 몽타주를 재생한다.
3. 태그가 없다면 현재 Combo Count에 맞는 몽타주를 재생한다.
4. Combo Count를 초기화 하고 이때도 마찬가지로 마지막 공격 전환 Tag를 캐릭터에게서 제거한다.

Jump To Finisher 공격 콤보 테스트

좌(Light_1~3 & Heavy_2) / 우(Heavy_1~2)

Light Attack_1~3 이후 바로 Heavy Attack을 시전하면 바로 Heavy Attack의 마무리 동작인 위에서 내려찍는 애니메이션이 정상적으로 재생된다.

Attack 몽타주에 효과 주기

✅ 슬로우 모션 효과

에디터에서 "AnimNotifyState"를 상속받는 블루프린트 클래스를 생성해준다.

좌측 상단에서 두 개의 함수를 Override 해준다.

Begin 함수에서 MeshComponent에 Dilation 설정을 해준다.
TimeDilation을 변수로 승격시키고, Default 값을 0.2로 준다.

End 함수에서 Time Dilation을 1.0으로 다시 기본 값으로 설정해준다.

Light / Heavy Attack의 마지막 콤보 애니메이션에 방금 만든 AnimNotifyState_SlowMotion을 적절한 위치에 배치해준다.

슬로우 모션 적용 테스트

Light / Heavy Attack 모두, 마지막 공격에 슬로우 모션이 걸리면서 강하게 힘을 모아 공격하는 듯한 연출이 가능해졌다.

GAS_08_무장 상태에 따른 Ability + IMC 설계

동그래님 — Wed, 7 May 2025 00:37:02 +0900

Unequip Ability 기본 세팅

현재까지 시스템을 고려할 때, 새로운 플레이어(Hero) 능력을 추가한다면 아래와 같은 순서로 적용시킬 가능성이 높다.

1. Ability Tag 생성
2. 새로운 몽타주 생성
3. Ability BP 생성
4. 이 능력을 부여하기 위한 Ability Input Action 처리

이 순서대로 빠르게 Unequip Ability를 세팅해보자.

1. Ability Tag 생성

#pragma once

#include "NativeGameplayTags.h"

namespace RPGGameplayTags
{
	/** Input Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Move);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Look);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_EquipAxe);
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_UnequipAxe);

	/** Player Tags */
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Equip_Axe); // 실제 도끼 장(탈)착 Ability Tag
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Ability_Unequip_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Weapon_Axe);

	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Equip_Axe);   // 해당 Anim에서 사용했던 Ability 활성화 Event Tag
	RPG_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(Player_Event_Unequip_Axe);
}

#include "RPGGameplayTags.h"

namespace RPGGameplayTags
{
	/** Input Tags */
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Move, "InputTag.Move");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Look, "InputTag.Look");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_EquipAxe, "InputTag.EquipAxe");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_UnequipAxe, "InputTag.UnequipAxe");

	/** Player Tags */
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Equip_Axe, "Player.Ability.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Ability_Unequip_Axe, "Player.Ability.Unequip.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Weapon_Axe, "Player.Weapon.Axe");

	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Equip_Axe, "Player.Event.Equip.Axe");
	UE_DEFINE_GAMEPLAY_TAG(Player_Event_Unequip_Axe, "Player.Event.Unequip.Axe");
}

앞서 AnimNotify로 도끼 장착 Ability가 발생해야되는 Event를 알려주는 Tag를 사용했었는데,
이제 실제로 해당 Ability에 관련한 Tag를 작성해준다.

2. Ability 관련 애니메이션 몽타주 생성

AnimNotify를 적절한 프레임 위치에 배치하고, Event Tag 설정

3. Ability BP 생성

무기 해제 Ability인 "GA_Hero_UnequipAxe" 생성

애니메이션 몽타주를 연결해주고 Wait Gameplay Event로 Event 수신

앞서 Ability Tag를 선언했었는데, 이를 바탕으로 Tag Setting을 진행한다.

AssetTags:
- 이 태그는 해당 GameplayAbility의 정체성
- 이 능력이 어떤 능력인지 명시하는 태그
- 다른 능력이나 조건에서 현재 어떤 능력이 활성화 되었는지 확인할 때 사용
Cancel Abilities with Tag:
- 현재 GA가 발동될 때, 이 카테고리에 있는 Tag가 붙은 Ability는 즉시 취소됨
Block Abilities with Tag:
- 이 Ability가 활성화 되어 있는 동안, 이 카테고리에 있는 Tag가 붙은 Ability는 발동할 수 없음
- 즉 현재는 도끼를 해제하는 Ability가 활성화 되었다면, 다른 장착/탈착 Ability는 Block처리

앞서 구현했었던 무기를 장착하는 "GA_Hero_EquipAxe"에도 Tag 설정을 해준다.

4. Ability Input Action 세팅

IA_UniqueAxe 클래스를 DA_InputConfig에 할당

Equip/Unequip에 따른 Ability 설계

Unequip Ability(장비 해제 능력)는 장비를 착용하고 있는 상태에서만 부여하고, 그때만 능력을 활성화하는 것이 자연스러울 것이다.
반대로 Equip Ability(장비 장착 능력)은 장비를 착용하고 있지 않은 상태에서 부여하고, 장비 착용 능력을 활성화 하면 해당 무기에 특화된 능력과 입력 키를 자동으로 부여하고, 해제 시 해당 능력과 입력 키를 제거하는 구조가 가장 이상적이다.

기존에 Weapon 클래스에 AnimLayer 데이터를 보관했는데 앞선 구조를 적용시키려면, 더 많은 데이터(IMC, Ability Set 등)를 무기가 가지고 있어야 한다.

DataAsset_HeroStartUpData.h 수정 전

#pragma once

#include "CoreMinimal.h"
#include "DataAssets/StartUpData/DataAsset_StartUpDataBase.h"
#include "GameplayTagContainer.h" // FGameplayTag 헤더
#include "DataAsset_HeroStartUpData.generated.h"

USTRUCT(BlueprintType)
struct FWarriorHeroAbilitySet
{
	GENERATED_BODY()

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, meta = (Category = "InputTag"))
	FGameplayTag InputTag;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	TSubclassOf<URPGGameplayAbility> AbilityToGrant;

	bool IsVaild() const;
};

UCLASS()
class RPG_API UDataAsset_HeroStartUpData : public UDataAsset_StartUpDataBase
{
	GENERATED_BODY()
	
public:
	// 플레이어 캐릭터의 ASC에 초기 능력을 부여
	virtual void GiveToAbilitySystemComponent(URPGAbilitySystemComponent* InRPG_ASC, int32 ApplyLevel = 1) override;

private:
	UPROPERTY(EditDefaultsOnly, Category = "StartUpData", meta = (TitleProperty = "InputTag"))
	TArray<FWarriorHeroAbilitySet> HeroStartUpAbilitySets;
};

DataAsset_HeroStartUpData.h 수정 후

#pragma once

#include "CoreMinimal.h"
#include "DataAssets/StartUpData/DataAsset_StartUpDataBase.h"
#include "RPGTypes/RPGStructTypes.h"
#include "DataAsset_HeroStartUpData.generated.h"

UCLASS()
class RPG_API UDataAsset_HeroStartUpData : public UDataAsset_StartUpDataBase
{
	GENERATED_BODY()
	
public:
	// 플레이어 캐릭터의 ASC에 초기 능력을 부여
	virtual void GiveToAbilitySystemComponent(URPGAbilitySystemComponent* InRPG_ASC, int32 ApplyLevel = 1) override;

private:
	UPROPERTY(EditDefaultsOnly, Category = "StartUpData", meta = (TitleProperty = "InputTag"))
	TArray<FWarriorHeroAbilitySet> HeroStartUpAbilitySets;
};

기존 "DataAsset_HeroStartUpData"에 정의되어있던 "FWarriorHeroAbilitySet" 구조체를 구조체 전용 클래스인 "RPGStructTypes" 클래스로 옮겨준다.

RPGStructTypes.h

#pragma once

#include "GameplayTagContainer.h"
#include "RPGStructTypes.generated.h"

class UWarriorHeroLinkedAnimLayer;
class URPGGameplayAbility;
class UInputMappingContext;

USTRUCT(BlueprintType)
struct FWarriorHeroAbilitySet
{
	GENERATED_BODY()

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, meta = (Category = "InputTag"))
	FGameplayTag InputTag;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	TSubclassOf<URPGGameplayAbility> AbilityToGrant;

	bool IsVaild() const;
};

USTRUCT(BlueprintType)
struct FRPGHeroWeaponData
{
	GENERATED_BODY()

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	TSubclassOf<UWarriorHeroLinkedAnimLayer> WeaponAnimLayerToLink;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	UInputMappingContext* WeaponInputMappingContext;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, meta = (TitleProperty = "InputTag"))
	TArray<FWarriorHeroAbilitySet> DefaultWeaponAbilities;
};

RPGStructTypes.cpp

#include "RPGTypes/RPGStructTypes.h"
#include "AbilitySystem/Abilities/RPGGameplayAbility.h"

bool FWarriorHeroAbilitySet::IsVaild() const
{
	return InputTag.IsValid() && AbilityToGrant;
}

무기 전용 키 설정을 위한 InputMappingContext와 Tag-Ability를 가지고 있는 FWarriorHeroAbilitySet 구조체 타입의 TArray를 선언해준다.

에디터로 돌아와서 IMC_Axe 이름의 InputMappingContext를 생성해준다.
"IA_UnequipAxe"를 바인딩 하고, 앞서 무기를 장착했던 키 1번과 동일하게 세팅해주었다.
빠른 테스트를 위해 기본 이동관련 맵핑 컨텍스트 재정의는 추후에 진행하고 무기 해제 InputAction만 바인딩 해주었다.

플레이어가 사용하는 BP_Axe에서 앞서 WeaponData에 추가했던 InputMappingText와 Input Tag - Ability를 바인딩해준다.

✅ 무기 장착(GA_Hero_EquipAxe) 후, 로직 수정

무기를 장착하는 Ability인 "GA_Hero_EquipAxe"에서 기존엔 무기가 가지고 있는 AnimLayer 정보를 가져와 SkeletalMesh에 Link 해주는 로직 하나였지만,
이에 더해 무기가 가지고 있는 IMC와 무기가 가지고 있는 Ability를 적용시키는 로직을 추가하도록 한다.

RPGAbilitySystemComponent.h

#pragma once

#include "CoreMinimal.h"
#include "AbilitySystemComponent.h"
#include "RPGTypes/RPGStructTypes.h"
#include "RPGAbilitySystemComponent.generated.h"

UCLASS()
class RPG_API URPGAbilitySystemComponent : public UAbilitySystemComponent
{
	GENERATED_BODY()
	
public:
	void OnAbilityInputPressed(const FGameplayTag& InInputTag);
	void OnAbilityInputReleased(const FGameplayTag& InInputTag);
	
    // 무기 전용 Ability 등록
	UFUNCTION(BlueprintCallable, Category = "RPG|Ability", meta = (ApplyLevel = "1"))
	void GrantHeroWeaponAbilities(
		const TArray<FWarriorHeroAbilitySet>& InDefaultWeaponAbilities,
		int32 ApplyLevel,
		TArray<FGameplayAbilitySpecHandle>& OutGrantAbilitySpecHandles);
	
    // 무기 전용 Ability 등록 해제
	UFUNCTION(BlueprintCallable, Category = "RPG|Ability")
	void RemovedGrantedHeroWeaponAbilities(UPARAM(ref) TArray<FGameplayAbilitySpecHandle>& InSpecHandlesToRemove);
};

RPGAbilitySystemComponent.cpp

#include "AbilitySystem/RPGAbilitySystemComponent.h"
#include "AbilitySystem/Abilities/RPGGameplayAbility.h"

void URPGAbilitySystemComponent::OnAbilityInputPressed(const FGameplayTag& InInputTag)
{
	if (!InInputTag.IsValid()) return;

	for (const FGameplayAbilitySpec& AbilitySpec : GetActivatableAbilities())
	{
		if (!AbilitySpec.DynamicAbilityTags.HasTagExact(InInputTag)) continue;

		TryActivateAbility(AbilitySpec.Handle);
	}
}

void URPGAbilitySystemComponent::OnAbilityInputReleased(const FGameplayTag& InInputTag)
{
}

void URPGAbilitySystemComponent::GrantHeroWeaponAbilities(const TArray<FWarriorHeroAbilitySet>& InDefaultWeaponAbilities, int32 ApplyLevel, TArray<FGameplayAbilitySpecHandle>& OutGrantAbilitySpecHandles)
{
	if (InDefaultWeaponAbilities.IsEmpty()) return;

	for (const FWarriorHeroAbilitySet& AbilitySet : InDefaultWeaponAbilities)
	{
		if (!AbilitySet.IsVaild()) continue;

		FGameplayAbilitySpec AbilitySpec(AbilitySet.AbilityToGrant);
		AbilitySpec.SourceObject = GetAvatarActor();
		AbilitySpec.Level = ApplyLevel;
		AbilitySpec.DynamicAbilityTags.AddTag(AbilitySet.InputTag);

		OutGrantAbilitySpecHandles.AddUnique(GiveAbility(AbilitySpec));
	}
}

void URPGAbilitySystemComponent::RemovedGrantedHeroWeaponAbilities(UPARAM(ref)TArray<FGameplayAbilitySpecHandle>& InSpecHandlesToRemove)
{
	if (InSpecHandlesToRemove.IsEmpty()) return;

	for (const FGameplayAbilitySpecHandle& SpecHandle : InSpecHandlesToRemove)
	{
		if (SpecHandle.IsValid())
		{
			ClearAbility(SpecHandle);
		}
	}

	InSpecHandlesToRemove.Empty();
}

ASC에 무기가 가지고 있는 전용 Ability들을 "GiveAbility()"로 능력을 부여하고, 나중에 무기가 해제되었을 때 무기 전용 Ability 역시 해제해야하기 때문에 SpecHandle을 캐싱해둘 수 있도록 한다.

WarriorHeroWeapon.h

#pragma once

#include "CoreMinimal.h"
#include "Items/Weapons/RPGWeaponBase.h"
#include "RPGTypes/RPGStructTypes.h"
#include "GameplayAbilitySpecHandle.h"
#include "WarriorHeroWeapon.generated.h"

UCLASS()
class RPG_API AWarriorHeroWeapon : public ARPGWeaponBase
{
	GENERATED_BODY()
	
public:
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "WeaponData")
	FRPGHeroWeaponData HeroWeaponData;

	UFUNCTION(BlueprintCallable)
	void AssignGrantedAbilitySpecHandles(const TArray<FGameplayAbilitySpecHandle>& InSpecHandles);

	UFUNCTION(BlueprintPure)
	TArray<FGameplayAbilitySpecHandle> GetGrantedAbilitySpecHandles() const;

private:
	TArray<FGameplayAbilitySpecHandle> GrantedAbilitySpecHandles;
};

WarriorHeroWeapon.cpp

#include "Items/Weapons/WarriorHeroWeapon.h"

void AWarriorHeroWeapon::AssignGrantedAbilitySpecHandles(const TArray<FGameplayAbilitySpecHandle>& InSpecHandles)
{
	GrantedAbilitySpecHandles = InSpecHandles;
}

TArray<FGameplayAbilitySpecHandle> AWarriorHeroWeapon::GetGrantedAbilitySpecHandles() const
{
	return GrantedAbilitySpecHandles;
}

ASC에서 캐싱해둔 SpecHandle 데이터는 무기 클래스에 보존해 놓는다.

에디터로 돌아와서 무기 장착 Ability에서 Function을 하나 추가해주고, "HandleEquipWeapon"이라 명명한다.
이름 그대로 무기를 장착하고 나서의 로직을 핸들링 하는 함수이다.
함수 인자로 플레이어 무기 클래스인 "Warrior Hero Weapon" 클래스 Object Reference를 받도록 한다.

무기 클래스를 로컬 변수로 캐싱 해두고, 무기 클래스가 가지고 있는 정보로 아래와 같은 로직을 작성한다.
1. 무기 클래스에서 Anim Layer 클래스를 SkeletalMesh에 Link 해준다.
2. 무기 전용 IMC를 Add Mapping Context로 등록해주고 우선순위를 1로 높여준다.(기존 Mapping 덮어 쓰기 위함)
3. 앞서 ASC에 구현했던 무기가 가지고 있는 전용 Ability를 ASC에 등록해주고, 캐싱된 데이터(SpecHandle)은 무기 클래스에 보존한다.

최종적으로 무기를 Attach하고 해당 무기를 방금 구현한 "HandleEquipWeapon" 함수로 넘겨주어서,
애니메이션, IMC, Ability를 적용 시켜주고, 마지막으로 HeroCombatComponent에 "Current Equipped Weapon Tag" 변수에 현재 장착 중인 무기 Tag를 저장해준다.

✅ 무기 해제(GA_Hero_UnequipAxe) 후, 로직 수정

앞서 무기를 장착했을 때, 애니메이션과 IMC, Ability를 등록해주었는데 반대로 무기를 해제 했을 경우엔 앞서 추가된 목록을 제거해주면 된다.

앞서 무기를 장착할 때와 같이, 무기 클래스를 전달 받는 함수를 선언한다.
해당 함수에서 AnimLayer 제거, Weapon 전용 IMC, Weapon 전용 Ability를 해제하는 로직을 구현한다.

최종적으로 무기를 해제하는 GameplayAbility가 활성화 되면 다음과 같은 순서로 로직이 실행된다.

1. 무기를 해제하는 Montage 재생
2. CombatComponent에 현재 장착 중인 무기 Tag 해제
3. 몽타주에서 무기를 등에 장착하는 시점을 AnimNotify로 EventTag 수신
4. 무기를 등 위치 소켓에 부착
5. 무기 클래스를 "Handle Unequip Weapon" 전달
6. 해당 함수 내에서 AnimLayer, 무기 전용 IMC, 무기 전용 Ability 제거

테스트 결과

무기를 장착하지 않았을 때는 GA_Hero_EquipAxe 능력만 활성화 되어 1개의 Ability를 가지고 있는 것을 볼 수 있고, 해당 Ability를 활성화해 무기를 장착하면 GA_Hero_UnequipAxe 능력이 활성화 되어 2개의 Ability를 가지고 있는 것을 볼 수 있다.
또한 움직이면서 무기를 장착하면 Weapon에 저장되어있는 AnimLayer로 애니메이션이 정상적으로 변경되고, 무기를 탈착하면 다시 기존의 애니메이션으로 돌아가는 것을 확인할 수 있었다.

GAS_07_무장 상태 애니메이션 전환 시스템 설계

동그래님 — Tue, 6 May 2025 17:10:06 +0900

애니메이션 전환 시스템

한 캐릭터가 여러 종류의 무기(권총, 소총, 저격총 등)를 사용한다고 하면, 각 무기 타입마다 애니메이션이 다를 것이다.
이것을 각 무기마다 Anim Graph에 직접 노드를 추가한다면 유지보수가 매우 어려워지게 된다.

언리얼의 Lyra 프로젝트의 경우도 무기가 여러 종류가 있는데, "Anim Layer Interface"를 사용해서 각 무기별 애니메이션 로직을 레이어별로 분리하여 처리하였다.
이 설계 방향은 무기나 상태 확장에 유연하고 애니메이션 그래프의 복잡도가 크게 감소하게 된다.

✅ Anim Layer Interface 생성 및 적용

에디터에서 Animation Layer Interface를 생성하고 클래스 이름을 "ALI_Hero"로 명명하였다.
기본 Animation Layer 이름을 "ArmedLocomotionState"로 변경해주었고, 이게 설정 끝이다.

기본적으로 설정되어있는 ABP_Hero에서 Property Access 노드를 추가한다.
OwningHeroCharacter→HeroCombatComponent→CurrentEquippedWeaponTag를 설정한다.

Locomotion을 다음과 같이 정리한다.
현재 이 AnimInstance를 소유하고 있는 캐릭터의 CombatComponent에 접근하여, 현재 장착중인 무기 Tag를 확인한다.
유효하다면 ArmedLocomotionState를 사용하고 현재 장착 중인 무기가 없다면, 비무장 Locomotion으로 설정한다.

마지막으로 앞서 만들었던 Animation Layer Interface인 ALI_Hero를 설정해준다
이 인터페이스로 무기별로 AnimInstance가 달라도 하나의 인터페이스로 공통 동작을 호출할 수 있게 된다.

✅ Anim Layer Interface를 상속 받은 ABP_Layer 구현

이전에 AnimInstacne 구조 설계할 때 생성했던 "WarriorHeroLinkedAnimLayer" 클래스로 각 무기 전용 Anim Layer(ABP)를 만들 것이다.

WarriorHeroLinkedAnimLayer.h

#pragma once

#include "CoreMinimal.h"
#include "AnimIstances/RPGBaseAnimInstance.h"
#include "WarriorHeroLinkedAnimLayer.generated.h"

class UWarriorHeroAnimInstance;

UCLASS()
class RPG_API UWarriorHeroLinkedAnimLayer : public URPGBaseAnimInstance
{
	GENERATED_BODY()
	
public:
	UFUNCTION(BlueprintPure, meta = (BlueprintThreadSafe))
	UWarriorHeroAnimInstance* GetHeroAnimInstance() const;
};

WarriorHeroLinkedAnimLayer.h

#include "AnimIstances/Hero/WarriorHeroLinkedAnimLayer.h"
#include "AnimIstances/Hero/WarriorHeroAnimInstance.h"

UWarriorHeroAnimInstance* UWarriorHeroLinkedAnimLayer::GetHeroAnimInstance() const
{
    return Cast<UWarriorHeroAnimInstance>(GetOwningComponent()->GetAnimInstance());
}

메인으로 사용되는 AnimInstance에서 GroundSpeed를 가져와야 하므로, Instance 반환 함수를 구현하였다.

에디터로 돌아와, "WarriorHeroLinkedAnimLayer"를 상속받는 ABP를 생성해준다.

이 ABP도 마찬가지로 앞서 생성했던 Animation Layer Interface를 구현한다.
좌측 "ArmedLocomotionState"를 더블클릭 해서 Animation Layer 세부 구현을 진행한다.

"Blendspace Player" 노드를 생성한 뒤 클릭해서 Detail 창에서 몇가지 설정을 해준다.
Y값은 사용하지 않기 때문에 "Expose As Pin"을 눌러 핀을 없애주었고, Blend Space에 "Expose As Pin"을 눌러 핀을 활성화 해주었다.

PropertyAcess 노드를 만든 뒤, 앞서 구현했던 "GetHeroAnimInstance" 함수를 통해 AnimInstance에서 GroundSpeed값을 가져온다.

"Blendspace Player" 노드의 X축 핀에 GroundSpeed 값을 연결해주고, Blend Space는 변수로 승격시켜준다.

지금 만든 "MasterAnimLayer_Hero" 클래스를 상속받는 ABP 클래스를 생성한다.
이 클래스를 상속받는 ABP가 각 무기마다 전용 Animation을 담는 클래스가 될 것이다.

이 Axe 무기 전용 Layer에 BlendSpace만 설정해준다. 앞선 포스팅에서 BlendSpace 1D 만드는 과정을 서술했으므로 BS를 만드는 과정은 따로 정리하지 않는다.

✅ 각 무기 클래스에 AnimLayer 정보 저장

각 무기마다 AnimLayer(ABP 클래스)를 저장해놓고, 특정 무기를 들었을 때 해당 ABP를 캐릭터에 동적으로 연결해줌으로써, 자동으로 무기별 전용 애니메이션이 동작하게 만드는 구조이다.

먼저 프로젝트 전체 구조체를 정리할 클래스를 만들고 그 안에 AnimLayer를 저장할 구조체를 선언한 뒤, 무기에 해당 구조체를 멤버변수로 가지고 있게할 것이다.
이후 GA_EquipAxe와 같은 Ability에서 무기를 장착하면 SkeletalMesh에 AnimLayer를 연결해주도록 한다.

RPGStructTypes.h

#pragma once

#include "RPGStructTypes.generated.h"

class UWarriorHeroLinkedAnimLayer;

USTRUCT(BlueprintType)
struct FRPGHeroWeaponData
{
	GENERATED_BODY()

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	TSubclassOf<UWarriorHeroLinkedAnimLayer> WeaponAnimLayerToLink;
};

방금 만들었던 도끼 전용 AnimLayer와 같이 무기별 AnimLayer를 담을 수 있는 구조체를 선언하였다.

WarriorHeroWeapon.h

#pragma once

#include "CoreMinimal.h"
#include "Items/Weapons/RPGWeaponBase.h"
#include "RPGTypes/RPGStructTypes.h"
#include "WarriorHeroWeapon.generated.h"

UCLASS()
class RPG_API AWarriorHeroWeapon : public ARPGWeaponBase
{
	GENERATED_BODY()
	
public:
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "WeaponData")
	FRPGHeroWeaponData HeroWeaponData;
};

플레이어 무기 클래스에 앞서 만든 구조체 타입 변수를 선언해준다.

HeroCombatComponent.h

#pragma once

#include "CoreMinimal.h"
#include "Components/Combat/PawnCombatComponent.h"
#include "HeroCombatComponent.generated.h"

class AWarriorHeroWeapon;

UCLASS()
class RPG_API UHeroCombatComponent : public UPawnCombatComponent
{
	GENERATED_BODY()
	
public:
	UFUNCTION(BlueprintCallable, Category = "RPG|Combat")
	AWarriorHeroWeapon* GetHeroCarriedWeaponByTag(FGameplayTag InWeaponTag) const;
};

HeroCombatComponent.cpp

#include "Components/Combat/HeroCombatComponent.h"
#include "Items/Weapons/WarriorHeroWeapon.h"

AWarriorHeroWeapon* UHeroCombatComponent::GetHeroCarriedWeaponByTag(FGameplayTag InWeaponTag) const
{
   return Cast<AWarriorHeroWeapon>(GetCharacterCarriedWeaponByTag(InWeaponTag));
}

GA에서 HeroCombatComponet를 가져와서 Tag기반으로 바로 무기 클래스를 가져와, 무기 클래스 안의 AnimLayer 데이터를 가져올텐데 조금 더 BP에서 코드를 단순화 하기 위해, HeroWeapon타입으로 캐스팅해 반환하는 헬퍼 함수를 작성해주었다.

컴파일 후, 에디터로 돌아와 "GA_Hero_EquipAxe"에 해당 무기안에 AnimLayer 데이터를 가져와서 연결시켜주었다.
그리고 Hero Combat Component에 현재 장착중인 무기의 Tag를 설정해주었다.

마지막으로 해당 무기에 AnimLayer 데이터를 할당해준다.

테스트 결과

무기가 계속 추가되더라도 기존 메인으로 사용되는 "ABP_Hero"에서 수정하는 것이 아닌,
"MasterAnimLayer_Hero" 클래스를 상속 받은 "AnimLayer_HeroAxe"와 같은 무기 전용 ABP를 만들어서 무기에 넣어주기만 하면 자동으로 해당 애니메이션이 재생되는 구조가 되었다.
이로써 슈팅 게임에서 권총 혹은 소총, 저격총 등 여러 무기를 장착했을 때 개별적인 애니메이션을 보다 더 쉽게 적용시킬 수 있을 것 같다.