Crat

32-16. 로그 라이크 - (3) 게임플레이 어빌리티 - (6) 뽑기 로직 리펙토링

Crat3 — Wed, 9 Jul 2025 14:06:11 +0900

0. 개요

기존에는 HUD - PlayerController - PlayerState - GameMode 간 다량의 델리게이트를 통해서 뽑기 로직을 실행했으나, 이 과정에서 구조가 복잡해지고 콜백 함수의 증가로 인해 로직 파악에 어려움이 있었다.

이를 언리얼의 레플리케이션 시스템을 이용하여 단순화하고, 온라인에서 작동하도록 수정한다.

1. PlayerState에서 멤버 변수 레플리케이션 하기

이제 뽑는 로직은 서버인 GameMode에서 진행하고, 뽑은 카드를 멤버 변수로 저장하고 있다가 UI에서 노출하는 방법을 사용할 것이다.

이렇게 하면 멤버 변수를 레플리케이션 하도록 지정하고 콜백 함수를 활용하여 UI를 띄우는 방식의 구조로 변경할 수 있다.

(1) 뽑은 카드를 멤버 변수로 저장하기 - 레플리케이션으로 지정

	UPROPERTY(ReplicatedUsing = OnRep_UpgradeCardInfo)
	TArray<FAuraAbilityUpgradeInfo> ReplicatedCardInfo;

	UFUNCTION()
	void OnRep_UpgradeCardInfo();

(2) 델리게이트 선언

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnCardsInitialized, TArray<FAuraAbilityUpgradeInfo>&, InitializedCards);

이 델리게이트는 HUD에서 바인딩할 것이며, 호출되면 뷰 포트에 위젯을 추가하고 카드의 뷰 모델들을 초기화한다.

	UPROPERTY()
	FOnCardsInitialized OnUpgradeCardsInitializedDelegate;

(2-1) AuraHUD - 델리게이트 바인딩

void AAuraHUD::InitOverlay(APlayerController *PC, APlayerState *PS, UAbilitySystemComponent *ASC, UAttributeSet *AS)
{
    // 위젯과 위젯 컨트롤러 생성
    checkf(OverlayWidgetClass, TEXT("Overlay Widget not Initialized. BP_AuraHUD"));
    checkf(OverlayWidgetControllerClass, TEXT("Overlay Widget Controller not Initialized. BP_AuraHUD"));

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    if (AAuraPlayerState* AuraPS = Cast<AAuraPlayerState>(PS))
    {
        AuraPS->OnUpgradeCardsInitializedDelegate.AddDynamic(this, &AAuraHUD::HandleRandomAbilityUpgradeInfos);
    }
}

(3) 레플리케이션 변수의 Setter 함수 내에서 델리게이트 호출

void SetUpgradeCardInfo(const TArray<FAuraAbilityUpgradeInfo>& NewCard);

void AAuraPlayerState::SetUpgradeCardInfo(const TArray<FAuraAbilityUpgradeInfo>& NewCard)
{
    ReplicatedCardInfo = NewCard;
    OnUpgradeCardsInitializedDelegate.Broadcast(ReplicatedCardInfo);
}

레플리케이션 변수의 정보를 저장하고 UI로 전달한다.

2. AuraGameMode에서 카드 뽑기

(1) PlayerController에서 서버로 카드 뽑기 요청하기 - 서버 RPC 함수

	UFUNCTION(Server, Reliable, BlueprintCallable)
	void Server_CreateCardSelection(AActor* InteractedActor);

void AAuraPlayerController::Server_CreateCardSelection_Implementation(AActor* InteractedActor)
{
    if (!HasAuthority())
        return;
    
    // 게임 모드에게 카드 뽑기를 요청
    if (AAuraGameModeBase* GameMode = Cast<AAuraGameModeBase>(GetWorld()->GetAuthGameMode()))
    {
        if (APawn* InteractedPawn = Cast<APawn>(InteractedActor))
        {
            if (APlayerController* PC = Cast<APlayerController>(InteractedPawn->GetController()))
            {
                // GameMode의 카드 뽑기 로직 호출
                GameMode->HandleInitializeCards(PC);
            }
        }
    }
}

위의 함수를 블루프린트나 C++ 코드 어디에선가 호출하면

void AAuraGameModeBase::HandleInitializeCards(APlayerController* PC)
{
	if (AAuraPlayerController* AuraPC = Cast<AAuraPlayerController>(PC))
	{
		if (AAuraPlayerState* AuraPS = AuraPC->GetPlayerState<AAuraPlayerState>())
		{
			auto RandomUpgradeInfos = GetRandomUpgradeInfosForActivatedAbility_Three(AuraPS);
			AuraPS->SetUpgradeCardInfo(RandomUpgradeInfos);

			// 카드 내 선택 버튼 브로드캐스트
			AuraPC->OnCardSelectedDelegate.Broadcast();
		}
	}
}

게임모드 내의 이 함수가 실행된다.

카드를 뽑는 메인 로직은 PlayerState의 함수를 그대로 GameMode로 가지고와 수정해서 사용한다.

    // 델리게이트 바인딩
    OnCardSelectedDelegate.AddUObject(this ,&AAuraPlayerController::HandleCardSelectionInitialized);

이 델리게이트는 카드 뽑기를 완료했을 때 호출하는 델리게이트이다.

void AAuraPlayerController::HandleCardSelectionInitialized()
{
    if (AAuraHUD* AuraHUD = Cast<AAuraHUD>(GetHUD()))
    {
        if (UMVVM_CardSelection* CardSelectionViewModel = AuraHUD->GetCardSelectionViewModel())
        {
            for (int32 i = 0; i < CardSelectionViewModel->GetNumCards(); ++i)
            {
                if (UMVVM_AbilityCard* CardViewModel = CardSelectionViewModel->GetCardViewModelByIndex(i))
                {
                    CardViewModel->OnUpgradeSelectedDelegate.AddDynamic(this, &AAuraPlayerController::HandleAbilityCardSelected);
                }
            }
        }
    }
}

모든 뷰 모델에 대해 선택 버튼에 업그레이드 적용 콜백 함수를 바인딩한다.

(2) 카드 뽑기 로직

	UFUNCTION()
	TArray<FAuraAbilityUpgradeInfo> GetRandomUpgradeInfosForActivatedAbility_Three(AAuraPlayerState* AuraPS);

TArray<FAuraAbilityUpgradeInfo> AAuraGameModeBase::GetRandomUpgradeInfosForActivatedAbility_Three(
	AAuraPlayerState* AuraPS)
{
    TArray<FGameplayTag> ActivatedAbilityTags = AuraPS->GetAllActiveAbilityTags();
    TArray<FGameplayTag> InActivatedAbilityTags;
	InActivatedAbilityTags.Empty();
    
    TArray<FAuraAbilityUpgradeInfo> RandomUpgradeInfos;
    RandomUpgradeInfos.Empty();

    // 글로벌 업그레이드 할당
    ActivatedAbilityTags.Add(FGameplayTag::RequestGameplayTag("Abilities.Fire"));
    ActivatedAbilityTags.Add(FGameplayTag::RequestGameplayTag("Abilities.Arcane"));
    ActivatedAbilityTags.Add(FGameplayTag::RequestGameplayTag("Abilities.Lightning"));

    // 어빌리티 습득 또는 레벨업 업그레이드 할당
    TArray<FGameplayTag> AllAbilitiesTags = FAuraGameplayTags::Get().GameplayAbilitiesTags;
    for (auto AbilityTag : AllAbilitiesTags)
    {
        InActivatedAbilityTags.AddUnique(AbilityTag);
    }
    
    // 주어진 어빌리티 태그에 대해 랜덤한 업그레이드 태그 뽑기
    if (UAbilityUpgradeInfo* Info = AbilityUpgradeInfo)
    {
        int ActivatedAbilityTagsNum = ActivatedAbilityTags.Num();
        int RandValue0 = UKismetMathLibrary::RandomIntegerInRange(0, ActivatedAbilityTagsNum-1);
        int RandValue1 = UKismetMathLibrary::RandomIntegerInRange(0, ActivatedAbilityTagsNum-1);
        int RandValue2 = UKismetMathLibrary::RandomIntegerInRange(0, ActivatedAbilityTagsNum-1);

        // 랜덤으로 뽑은 어빌리티 태그는 중복 가능 -> 파이어볼트 업그레이드 2개 노출 가능
        const auto Tag0 = ActivatedAbilityTags[RandValue0];
        const auto Tag1 = ActivatedAbilityTags[RandValue1];
        const auto Tag2 = ActivatedAbilityTags[RandValue2];
        
        FGameplayTag UpgradeTag0;
        FGameplayTag UpgradeTag1;
        FGameplayTag UpgradeTag2;

        // 루프 함수 제한
        int CurrentAttempt = 0;
        
        // 동일한 태그가 없을 때까지 뽑기
        while (UpgradeTag0 == UpgradeTag1 || UpgradeTag1 == UpgradeTag2 || UpgradeTag0 == UpgradeTag2)
        {
            UpgradeTag0 = Info->GetRandomUpgradeTagForAbility(Tag0);
            UpgradeTag1 = Info->GetRandomUpgradeTagForAbility(Tag1);
            UpgradeTag2 = Info->GetRandomUpgradeTagForAbility(Tag2);

            CurrentAttempt++;

            if (CurrentAttempt > 30)
                break;
        }

        RandomUpgradeInfos.Add(Info->GetUpgradeInfoForUpgradeTag(UpgradeTag0));
        RandomUpgradeInfos.Add(Info->GetUpgradeInfoForUpgradeTag(UpgradeTag1));
        RandomUpgradeInfos.Add(Info->GetUpgradeInfoForUpgradeTag(UpgradeTag2));
    }

    return RandomUpgradeInfos;
}

카드의 글로벌 데미지(또는 효과) 증가 업그레이드와 획득(또는 비획득)한 스펠 레벨업 카드, 보유한 어빌리티의 업그레이드 정보 가져오기 등 세 가지의 로직이 모두 섞여있기 때문에 추후에 분리해야 한다.

24-3. 엔진 업그레이드 - (2) MVVM - 로드 및 저장 UI 버그 수정

Crat3 — Tue, 8 Jul 2025 19:42:39 +0900

0. 개요

언리얼 엔진의 버전이 올라가면서 베타 스테이지에 있던 MVVM 플러그인에 약간 변화가 생기면서 기존의 MVVM 위젯이 작동하지 않은 버그가 발생했다.

1. 버그가 발생한 이유

UE 5.3 부터 MVVM 플러그인이 변화했는데, 뷰 모델의 생성 타입(Creation Type)이 수동(Manual)일 때, 뷰 모델의 필드 노티파이가 위젯의 어떤 요소에도 바인드 되지 않았다면, 위젯에서 뷰 모델을 할당하는 데에 실패하게 된다.

따라서, 버그를 해결하기 위해서는 '필드 노티파이를 위젯의 어떤 한 요소에라도 바인딩'해야 한다.

2. 버그 수정

(1) 로드 슬롯 타입 별 필드 노티파이 바인드

(1-1) MVVM_LoadSlot 뷰 모델

MVVM_LoadSlot 내의 멤버 변수 중 하나였던 로드 슬롯 이름을 필드 노티파이로 설정한다.

이 이름은 플레이할 때 실제로 노출되지 않는다.

	UPROPERTY(EditAnywhere, BlueprintReadWrite, FieldNotify, Setter, Getter, meta = (AllowPrivateAccess = "true"))
	FString LoadSlotName;

public:
	/* Getter, Setter */
	void SetPlayerName(FString InPlayerName);
	void SetLevel(int32 InLevel);
	void SetMapName(FString InMapName);
	void SetLoadSlotName(FString InSlotName);

	FString GetPlayerName() const { return PlayerName; }
	int32 GetLevel() const { return Level;}
	FString GetMapName() const { return MapName; }
	FString GetLoadSlotName() const {return LoadSlotName;}

void UMVVM_LoadSlot::SetLoadSlotName(FString InSlotName)
{
    UE_MVVM_SET_PROPERTY_VALUE(LoadSlotName, InSlotName);
}

(1-2) 뷰 모델 내의 필드 노티파이 변수 바인드

WBP_LoadSlot 의 여러 종류 위젯 내에 텍스트 박스를 만들고 위의 슬롯 이름을 바인드한다.

(2) WBP_LoadScreen

위의 할당 된 BP Load Screen View Model이 null로 나타난다.

이 위젯의 뷰 모델은 Property Path로 설정되어 있어 특정 함수로 뷰 모델을 감지하는데, 뷰 모델의 필드 노티파이가 바인드 되지 않았기 때문에 뷰 모델이 null로 나타나고 있다.

따라서 뷰 모델 바인드를 진행한다.

32-15. 로그 라이크 - (7) 데미지 계산(ExecCalc) - (1) 속성 추가 데미지 업그레이드

Crat3 — Wed, 2 Jul 2025 17:59:17 +0900

0. 개요

속성 데미지를 증가시키는 게임플레이 어빌리티 업그레이드 태그를 가지고 있으면 해당 스펠 데미지를 증가시키도록 데미지 계산 식을 수정한다.

1. 속성 추가 데미지

(1) Native 게임플레이 태그 생성

FGameplayTag Upgrades_Fire_Increase10PercentDamage;

FGameplayTag Upgrades_Arcane_Increase10PercentDamage;

FGameplayTag Upgrades_Lightning_Increase10PercentDamage;

	GameplayTags.Upgrades_Fire_Increase10PercentDamage = UGameplayTagsManager::Get().AddNativeGameplayTag(
	FName("Upgrades.Fire.Increase10PercentDamage"),
	FString("Increase Damage of Fire SpellDamage")
	);

	GameplayTags.Upgrades_Arcane_Increase10PercentDamage = UGameplayTagsManager::Get().AddNativeGameplayTag(
	FName("Upgrades.Arcane.Increase10PercentDamage"),
	FString("Increase Damage of Arcane SpellDamage")
	);

	GameplayTags.Upgrades_Lightning_Increase10PercentDamage = UGameplayTagsManager::Get().AddNativeGameplayTag(
	FName("Upgrades.Lightning.Increase10PercentDamage"),
	FString("Increase Damage of Lightning SpellDamage")
	);

(2) ExecCalc_Damage의 Execute_Implementation 수정

		// 속성 저항이 데미지를 퍼센트로 무시함
		DamageTypeValue *= (100.f - Resistance) / 100.f;
		Damage += DamageTypeValue;

		if (AAuraCharacter* AuraCharacter = Cast<AAuraCharacter>(SourceAvatar))
		{
			if (AAuraPlayerState* AuraPS = AuraCharacter->GetPlayerState<AAuraPlayerState>())
			{
				// 화염 데미지 증가
				if (AuraPS->HasUpgradeTag(Tags.Upgrades_Fire_Increase10PercentDamage))
				{
					int Stacks = AuraPS->GetUpgradeTagCount(Tags.Upgrades_Fire_Increase10PercentDamage);

					Damage += Damage * 0.1f * Stacks;
				}
				// 전기 데미지 증가
				if (AuraPS->HasUpgradeTag(Tags.Upgrades_Lightning_Increase10PercentDamage))
				{
					int Stacks = AuraPS->GetUpgradeTagCount(Tags.Upgrades_Lightning_Increase10PercentDamage);

					Damage += Damage * 0.1f * Stacks;
				}
				// 화염 데미지 증가
				if (AuraPS->HasUpgradeTag(Tags.Upgrades_Arcane_Increase10PercentDamage))
				{
					int Stacks = AuraPS->GetUpgradeTagCount(Tags.Upgrades_Arcane_Increase10PercentDamage);

					Damage += Damage * 0.1f * Stacks;
				}
			}
		}

24-2. 엔진 업그레이드 - (1) 게임플레이 어빌리티 - (1) 아케인 파편 수정

Crat3 — Mon, 30 Jun 2025 20:12:44 +0900

0. 개요

향상된 입력 시스템의 변화에 따라 어빌리티 활성화 이후 InputPress 함수가 호출되도록 바뀌었다.

변경된 구조를 이용하고 기존의 블루프린트 로직을 C++로 이관한다.

1. 범위 표시기 - MagicCircle 수정

어빌리티 내에서 Show Magic Circle / Hide Magic Circle을 이용하여 BP_MagicCircle을 생성 / 제거하고 있다.

이 때, UI에 나타나는 문구는 게임플레이 큐를 이용하는데, 이 게임플레이 큐를 각 어빌리티 내에서 부여하고 있다.

해당 로직을 MagicCircle 내로 옮긴다.

(1) MagicCircle

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnCircleInitialized, AActor*, AvatarActor);

UCLASS()
class AURA_API AMagicCircle : public AActor
{
	GENERATED_BODY()
	
public:	
	AMagicCircle();
	virtual void Tick(float DeltaTime) override;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
	TObjectPtr<UDecalComponent> MagicCircleDecal;

	UPROPERTY(BlueprintAssignable)
	FOnCircleInitialized CircleInitialized;

	UPROPERTY(BlueprintAssignable)
	FOnCircleInitialized RemoveCircle;
	
protected:
	virtual void BeginPlay() override;
};

블루프린트 델리게이트를 추가하고 매개 변수로 액터를 넘겨준다.

(2) BP_MagicCircle

델리게이트에 각각 게임플레이 큐를 추가하는 이벤트와 태그를 제거하는 이벤트를 바인딩한다.

2. 아케인 파편 어빌리티 - C++

블루프린트 이벤트 그래프의 로직 대부분을 C++ 코드로 변경한다.

(1) 마우스 적중 결과 처리 함수

void UArcaneShards::ReceivedMouseHitResult(const FGameplayAbilityTargetDataHandle& TargetDataHandle)
{
    if (!TargetDataHandle.IsValid(0))
       return;

    const FGameplayAbilityTargetData* TargetData = TargetDataHandle.Get(0);
    const FHitResult* HitResult = TargetData->GetHitResult();

    // 마우스 히트 정보를 멤버 변수로 만듬
    CurrentMouseLocation = HitResult->ImpactPoint;
    NumPoints = GetAbilityLevel();

    GroundPoints.Empty();

    // 어빌리티 업그레이드 확인
    CheckAbilityUpgrades(FAuraGameplayTags::Get().Abilities_Arcane_ArcaneShards);
    
    FTransform PointCollectionTransform;
    PointCollectionTransform.SetLocation(CurrentMouseLocation);

    PointCollection = GetWorld()->SpawnActorDeferred<APointCollection>(
       PointCollectionClass,
       PointCollectionTransform,
       GetAvatarActorFromActorInfo(),
       nullptr,
       ESpawnActorCollisionHandlingMethod::AlwaysSpawn);

    PointCollection->FinishSpawning(PointCollectionTransform);

    GroundPoints = PointCollection->GetGroundPoints(FMath::Min(NumPoints, MaxNumShards));
}

TargetDataUnderMouse가 반환하는 데이터 핸들을 직접 받아 바닥에 포인트 컬렉션을 생성하는 작업까지 진행한다.

(2) 타이머 설정 함수

void UArcaneShards::ReadyToSpawnShards()
{
	AActor* AvatarActor = GetAvatarActorFromActorInfo();

	// 범위 표시기 제거
	if (AvatarActor->Implements<UPlayerInterface>())
	{
		IPlayerInterface::Execute_HideMagicCircle(AvatarActor);
	}

	// UI 범위기 메시지 제거
	RemoveRangeSpellHelpMessage(AvatarActor);
	
	if (UWorld* World = GetWorld())
	{
		World->GetTimerManager().SetTimer(ShardSpawnTimer, this, &UArcaneShards::SpawnShards,SpawnShardsDeltaTime, true);
	}

	// 쿨다운, 코스트 적용
	CommitAbility(GetCurrentAbilitySpecHandle(),
		GetCurrentActorInfo(),
		GetCurrentActivationInfo());
}

범위 표시기를 제거하고 타이머를 생성하여 DeltaTime 변수에 따라서 파편 기둥을 소환한다.

(3) 파편 기둥 소환 - 타이머 핸들의 콜백 함수

void UArcaneShards::SpawnShards()
{
	AActor* AvatarActor = GetAvatarActorFromActorInfo();
	
	if (Idx < GroundPoints.Num())
	{
		// 파편 위치 계산
		ShardSpawnLocation = GroundPoints[Idx]->GetComponentTransform().GetLocation();
		ShardSpawnRotation = GroundPoints[Idx]->GetComponentTransform().GetRotation().Rotator();

		TArray<AActor*> ActorsToIgnore;
		ActorsToIgnore.Empty();
		ActorsToIgnore.Add(AvatarActor);
		
		TArray<AActor*> OutOverlappingActors;
		OutOverlappingActors.Empty();

		// 데미지 입힐 플레이어 계산
		UAuraAbilitySystemLibrary::GetLivePlayersWithinRadius(
			AvatarActor,
			OutOverlappingActors,
			ActorsToIgnore,
			RadialDamageOuterRadius,
			ShardSpawnLocation);

		for (AActor* DamagedActor : OutOverlappingActors)
		{
			if (!IsValid(DamagedActor))
				continue;

			// 아군이라면 건너뛰기
			if (!UAuraAbilitySystemLibrary::IsNotFriend(DamagedActor, AvatarActor))
			{
				continue;
			}

			// 클래스 디폴트를 이용하여 데미지 이펙트 파라미터 생성
			FVector DirectionOverride = DamagedActor->GetActorLocation() - ShardSpawnLocation;
			FDamageEffectParams Params = MakeDamageEffectParamsFromClassDefaults(
				DamagedActor,
				ShardSpawnLocation,
				true,
				DirectionOverride,
				true,
				DirectionOverride,
				true,
				45.f);

			// 데미지 적용
			UAuraAbilitySystemLibrary::ApplyDamageEffect(Params);
		}
		
		// 아케인 파편 기둥 이펙트 생성
		FGameplayCueParameters CueParams;
		CueParams.Location = ShardSpawnLocation;
		CueParams.Normal = UKismetMathLibrary::GetRightVector(ShardSpawnRotation);
			
		K2_ExecuteGameplayCueWithParams(FGameplayTag::RequestGameplayTag("GameplayCue.ArcaneShards"), CueParams);
	}
	
	if (Idx >= GroundPoints.Num())
		EndSpawnShards();
	else
		Idx++;
}

파편 기둥을 하나씩 생성하면서 데미지를 입히고, 기둥 플레이 큐를 생성한다.

(4) 파편 소환 종료

void UArcaneShards::EndSpawnShards()
{
	PointCollection->Destroy();

	EndAbility(
		GetCurrentAbilitySpecHandle(),
		GetCurrentActorInfo(),
		GetCurrentActivationInfo(),
		true, false);
}

포인트 컬렉션을 파괴하고 어빌리티를 종료한다.

(5) EndAbility

void UArcaneShards::EndAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo,
                               const FGameplayAbilityActivationInfo ActivationInfo, bool bReplicateEndAbility, bool bWasCancelled)
{
	Super::EndAbility(Handle, ActorInfo, ActivationInfo, bReplicateEndAbility, bWasCancelled);

	auto* AvatarActor = GetAvatarActorFromActorInfo();
	if (AvatarActor->Implements<UPlayerInterface>())
	{
		IPlayerInterface::Execute_HideMagicCircle(GetAvatarActorFromActorInfo());
	}
	
	// 데미지 입힘 종료
	if (UWorld* World = GetWorld())
	{
		World->GetTimerManager().ClearTimer(ShardSpawnTimer);
	}

	// 포인트 컬렉션이 아직도 파괴되지 않았으면 파괴
	if (IsValid(PointCollection))
		PointCollection->Destroy();
}

범위 표시기가 사라지지 않았을 경우를 대비하여 범위 표시기를 제거한다. 포인트 컬렉션도 마찬가지이다.

3. 아케인 파편 어빌리티 - 블루프린트 이벤트 그래프

기존의 범위 지정 데칼과 자동 이동 중지 로직은 유지하고, 나머지 로직은 C++ 함수로 대체한다.

EndAbility 이벤트도 제거한다.

24-1. 엔진 업그레이드 - 컴파일 오류 해결

Crat3 — Mon, 30 Jun 2025 16:29:28 +0900

1. Target.cs 변경

using UnrealBuildTool;
using System.Collections.Generic;

public class AuraEditorTarget : TargetRules
{
	public AuraEditorTarget(TargetInfo Target) : base(Target)
	{
		Type = TargetType.Editor;
		DefaultBuildSettings = BuildSettingsVersion.V5;
		IncludeOrderVersion = EngineIncludeOrderVersion.Latest;
		CppStandard = CppStandardVersion.Cpp20;

		ExtraModuleNames.AddRange( new string[] { "Aura" } );
	}
}

- C++ 표준이 C++ 17에서 C++ 20으로 변경되었다.

- 빌드 세팅 버전이 V2에서 V5로 변경되었다.

2. 코드 변경

(1) FOverlapResult 구조체

이전 버전과 다르게 오버랩 된 결과를 사용하기 위해서는 아래의 헤더를 첨부해야 한다.

#include "Engine/OverlapResult.h"

(2) 어빌리티의 게임플레이 태그 컨테이너 접근

어빌리티 스펙의 어빌리티 태그 컨테이너에 접근할 때, 직접 접근하지 않고 Getter로 접근하도록 변경되었다.

        FGameplayAbilitySpec LoadedAbilitySpec = FGameplayAbilitySpec(LoadedAbilityClass, Data.AbilityLevel);
        LoadedAbilitySpec.DynamicAbilityTags.AddTag(Data.AbilitySlot);
        LoadedAbilitySpec.DynamicAbilityTags.AddTag(Data.AbilityStatus);

        FGameplayAbilitySpec LoadedAbilitySpec = FGameplayAbilitySpec(LoadedAbilityClass, Data.AbilityLevel);
        LoadedAbilitySpec->GetDynamicSpecSourceTags().AddTag(Data.AbilitySlot);
        LoadedAbilitySpec->GetDynamicSpecSourceTags().AddTag(Data.AbilityStatus);

어빌리티의 에셋 태그 컨테이너 에 접근할 때, 직접 접근하지 않고 Getter로 접근하도록 변경되었다.

void UAuraPassiveAbility::ReceiveDeactivate(const FGameplayTag& AbilityTag)
{
    if (AbilityTags.HasTagExact(AbilityTag))
    {
       EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, true);
    }
}

void UAuraPassiveAbility::ReceiveDeactivate(const FGameplayTag& AbilityTag)
{
	if (GetAssetTags().HasTagExact(AbilityTag))
	{
		EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, true);
	}
}

(3) 입력 레플리케이션 변경

//InvokeReplicatedEvent(EAbilityGenericReplicatedEvent::InputPressed, AbilitySpec.Handle, AbilitySpec.ActivationInfo.GetActivationPredictionKey());

향상된 입력(Enhanced Input)의 변경점과 더불어 GAS 내부의 레플리케이션 변경으로 인해 비 인스턴스화 된 어빌리티에 접근할 수 없게 되었다.

향상된 입력이 변경됨에 따라서 AbilitySpecInputPressed가 ASC에서 호출되면 자동으로 어빌리티의 InputPress 함수가 호출되도록 변경되었다.

(4) 게임플레이 이펙트가 부여하는 태그 컨테이너에 접근 변화

     Effect->InheritableOwnedTagsContainer.AddTag(DebuffTag);
    
     // 스턴 상태
     if (DebuffTag.MatchesTagExact(GameplayTags.Debuff_Stun))
     {
         Effect->InheritableOwnedTagsContainer.AddTag(GameplayTags.Player_Block_CursorTrace);
         Effect->InheritableOwnedTagsContainer.AddTag(GameplayTags.Player_Block_InputHeld);
         Effect->InheritableOwnedTagsContainer.AddTag(GameplayTags.Player_Block_InputPressed);
         Effect->InheritableOwnedTagsContainer.AddTag(GameplayTags.Player_Block_InputReleased);
     }

생성한 게임플레이 이펙트가 액터에 적용되기 전에 특정 태그를 추가하려면 GrantedTag를 활용하도록 변경되었다.

    FGameplayEffectSpec* MutableSpec = new FGameplayEffectSpec(Effect, EffectContext, 1.f/*Debuff Level*/);
    if (MutableSpec)
    {
        FAuraGameplayEffectContext* AuraContext = static_cast<FAuraGameplayEffectContext*>(EffectContext.Get());
        TSharedPtr<FGameplayTag> DebuffDamageType = MakeShareable(new FGameplayTag(DamageType));
        AuraContext->SetDamageType(DebuffDamageType);

        // 디버프 태그 적용
        MutableSpec->DynamicGrantedTags.AddTag(DebuffTag);
        if (DebuffTag.MatchesTagExact(GameplayTags.Debuff_Stun))
        {
            MutableSpec->DynamicGrantedTags.AddTag(GameplayTags.Player_Block_CursorTrace);
            MutableSpec->DynamicGrantedTags.AddTag(GameplayTags.Player_Block_InputHeld);
            MutableSpec->DynamicGrantedTags.AddTag(GameplayTags.Player_Block_InputPressed);
            MutableSpec->DynamicGrantedTags.AddTag(GameplayTags.Player_Block_InputReleased);
        }
    }

24. 언리얼 엔진 업그레이드 (UE 5.2 -> UE 5.6)

Crat3 — Mon, 30 Jun 2025 15:07:26 +0900

1. GAS (Gameplay Ability System) 주요 변경점

(1) 쿨다운 게임플레이 이펙트 변화

GameplayTag removal in GameplayEffect Component does not work? : r/unrealengine

이전 버전에서는 쿨다운 게임플레이 이펙트를 생성하여 해당 이펙트 내에서 Granted Tag로 쿨다운 태그를 지정하여 어빌리티에 연결하는 방법을 사용했으나, 이제는 쿨다운이 모듈화되어 컴포넌트 배열에서 'Target Tags Gameplay Effect Component'를 추가하여 태그를 할당하고 사용할 수 있다.

(2) 어빌리티 시스템 초기화

GAS 예시 프로젝트 GitHub - Narxim/Narxim-GAS-Example: A basic setup for using Epic's Gameplay Ability System.

게임 시작 이후에, 캐릭터의 기본 어트리뷰트를 초기화하는 방법이 새로 생겼다.

(3) Native 게임플레이 태그 선언 변화

이전 버전에서는 DefaultGameplayTags.ini 에 게임플레이 태그를 등록하여 사용하거나, C++ 코드 상에서 정의하여 사용하는 방법이 있었으나, 최근 버전에서는 C++ 코드 상에서 정의하여 사용하는 방법만 유효하다.

(4) Enhanced Input 변경점

기존의 Input Action을 태그와 연결하고, 태그가 부여되면 어빌리티를 활성화하는 로직에서 직접 어빌리티가 입력에 반응하도록 변경되었다.

또한 새로운 어빌리티 태스크 노드가 추가되었다.

32-14. 로그 라이크 - (3) 게임플레이 어빌리티 - (5) 화염 폭풍 스펠

Crat3 — Fri, 27 Jun 2025 15:03:31 +0900

0. 개요

범위를 지정하여 사용하면 적을 추적함과 동시에 적을 빨아들이며 도트(DoT ; Damage over Time) 데미지를 가하는 화염 폭풍 스펠을 설계한다.

1. 게임플레이 어빌리티 기초 설계

(1) Native 게임플레이 태그 생성

	FGameplayTag Abilities_Fire_Firenado;

	GameplayTags.Abilities_Fire_Firenado = UGameplayTagsManager::Get().AddNativeGameplayTag(
		FName("Abilities.Fire.Firenado"),
		FString("Firenado Ability")
	);

(2) 스펠 메뉴에 어빌리티 태그 할당

(3) DA_AbilityInfo에 데이터 추가

(4) 애님 몽타주 생성 및 모션워핑 노티파이, 게임플레이 큐 노티파이 추가

2. 파이어 토네이도 액터

(1) C++ 코드

class UCapsuleComponent;

UCLASS()
class AURA_API AAuraFireTornado : public AActor
{
	GENERATED_BODY()

	AAuraFireTornado();

protected:
	virtual void BeginPlay() override;
	virtual void Tick(float DeltaSeconds) override;
	virtual void Destroyed() override;

public:
	void SetDamageDeltaSecond(float InTime) {DamageDeltaSecond = InTime;}
	void SetDamageRadius(float InDamageRadius) {DamageRadius = InDamageRadius;}
	void SetFollowRadius(float InFollowRadius) {FollowRadius = InFollowRadius;}

protected:
	UFUNCTION()
	void ApplyDamageAndKnockback();
	
	bool IsValidOverlap(AActor* OtherActor);

public:
	UPROPERTY(BlueprintReadWrite, meta=(ExposeOnSpawn = true))
	FDamageEffectParams DamageEffectParams;
	
protected:
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
	TObjectPtr<UCapsuleComponent> Capsule;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	TObjectPtr<UStaticMeshComponent> Mesh;
	
	UPROPERTY(VisibleAnywhere)
	TObjectPtr<UAudioComponent> LoopingSoundComponent;
	
private:
	UPROPERTY(EditDefaultsOnly)
	float LifeSpan = 15.f;
	
	UPROPERTY(EditDefaultsOnly)
	float MovementSpeed = 1.f;
	
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, meta=(AllowPrivateAccess=true))
	float DamageDeltaSecond = 0.2f;

	UPROPERTY(EditDefaultsOnly)
	float FollowRadius = 600.f;
	
	UPROPERTY(EditDefaultsOnly)
	float DamageRadius = 300.f;

	UPROPERTY(EditDefaultsOnly)
	float SpinDegreePerSecond = -360.f;
	
	UPROPERTY(EditAnywhere)
	TObjectPtr<USoundBase> LoopingSound;

	UPROPERTY(BlueprintReadWrite, meta=(AllowPrivateAccess = true))
	TArray<AActor*> OverlappingActors;
};

데미지 로직이 액터 내에 위치하기 때문에, 적을 끌어오는 범위, 유지 시간, 데미지 범위를 외부에서(게임플레이 어빌리티에서) 설정할 수 있도록 해야 한다.

(1-1) 생성자 / 비긴 플레이 / 파괴

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

	Mesh = CreateDefaultSubobject<UStaticMeshComponent>("Mesh");
	SetRootComponent(Mesh);

	Capsule = CreateDefaultSubobject<UCapsuleComponent>("Capsule");
	
	Capsule->SetCollisionObjectType(ECC_Projectile);
	Capsule->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
	Capsule->SetCollisionResponseToAllChannels(ECR_Ignore);
	Capsule->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
	Capsule->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
	Capsule->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
	Capsule->SetupAttachment(GetRootComponent());
}

void AAuraFireTornado::BeginPlay()
{
	Super::BeginPlay();
	SetLifeSpan(LifeSpan);
	SetReplicateMovement(true);
	
	LoopingSoundComponent = UGameplayStatics::SpawnSoundAttached(LoopingSound, GetRootComponent());
}

컴포넌트에 대한 기본 설정을 한다.

스태틱 메시를 루트로 지정하고 캡슐을 하위로 지정하여 메시 크기에 따라 캡슐도 유동적으로 스케일링되도록 한다.

void AAuraFireTornado::Destroyed()
{
	if (LoopingSoundComponent)
	{
		LoopingSoundComponent->Stop();
		LoopingSoundComponent->DestroyComponent();
	}
	
	Super::Destroyed();
}

(1-2) 틱 - 적을 향해 추적하여 따라가기

void AAuraFireTornado::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);

    FRotator DeltaRotation = FRotator(0.f, SpinDegreePerSecond * DeltaSeconds, 0.f);
    AddActorWorldRotation(DeltaRotation);

    if (!OverlappingActors.IsEmpty())
    {
       AActor* TargetActor = OverlappingActors.Last();

       if (!IsValid(TargetActor))
          return;

       FVector TornadoLocation = GetActorLocation();
       FVector ActorLocation = TargetActor->GetActorLocation();

       ActorLocation.Z = TornadoLocation.Z;

       FVector NewLocation = FMath::VInterpTo(TornadoLocation, ActorLocation, DeltaSeconds, MovementSpeed);
       SetActorLocation(NewLocation, true);
    }
}

데미지를 주는 함수 내에서 획득한 Overlapping Actors 배열을 이용하여 가장 외곽에 있는 적을 추적하게 한다.

선형 보간을 이용하여 서서히 움직이게 한다.

(1-3) 데미지, 넉백 함수

void AAuraFireTornado::ApplyDamageAndKnockback()
{
	OverlappingActors.Empty();
	
	TArray<AActor*> IgnoreActors;
	IgnoreActors.AddUnique(GetOwner());
	
	UAuraAbilitySystemLibrary::GetLivePlayersWithinRadius(
		this,
		OverlappingActors,
		IgnoreActors,
		FollowRadius,
		GetActorLocation());

	// 1. 중앙으로 끌어 당김
	// 2. 틱 데미지 부여
	// 3. 범위 밖의 액터를 향해 느리게 움직임
	
	for (AActor* OtherActor : OverlappingActors)
	{
		if (IsValidOverlap(OtherActor) == false)
			continue;

		if (HasAuthority())
		{
			if (auto* TargetASC = UAbilitySystemBlueprintLibrary::GetAbilitySystemComponent(OtherActor))
			{
				bool bIsKnockBack = true;
				
				// 벡터를 구하고 정규화
				FVector ToCenter = GetActorLocation() - OtherActor->GetActorLocation();
				ToCenter.Z = GetActorLocation().Z - Capsule->GetScaledCapsuleHalfHeight();
				ToCenter.Normalize();
				
				// 보스는 넉백 무효
				if (OtherActor->ActorHasTag(FName("Boss")))
				{
					bIsKnockBack = false;
					DamageEffectParams.KnockbackChance = 0.f;
				}

				if (bIsKnockBack)
				{
					const FVector KnockbackDirection = ToCenter;
					const FVector KnockbackForce = KnockbackDirection * DamageEffectParams.KnockbackForceMagnitude;
					DamageEffectParams.KnockbackForce = KnockbackForce;
				}

				FVector DistanceVector = (OtherActor->GetActorLocation()-GetActorLocation());
				float Distance = DistanceVector.Length();
				
				if (Distance <= DamageRadius)
				{
					const FVector DeathImpulse = ToCenter * DamageEffectParams.DeathImpulseMagnitude;
					DamageEffectParams.DeathImpulse = DeathImpulse;
					DamageEffectParams.TargetAbilitySystemComponent = TargetASC;
				
					UAuraAbilitySystemLibrary::ApplyDamageEffect(DamageEffectParams);
				}
			}
		}
	}
}

- 파이어 토네이도 액터 주위로 '견인 범위'를 검사하여 겹치는 액터를 반환한다.

- 보스가 아닌 적을 대상으로 파이어 토네이도 액터 중심으로 넉백 벡터를 지정한다.

- 파이어 토네이도 액터와 대상 사이의 거리를 체크하여 '데미지 범위' 내에 있으면 데미지 게임플레이 이펙트를 적용한다.

(1-4) 겹침 판정 검증 함수

bool AAuraFireTornado::IsValidOverlap(AActor* OtherActor)
{
	if (DamageEffectParams.SourceAbilitySystemComponent == nullptr)
		return false;

	AActor* SourceAvatarActor = DamageEffectParams.SourceAbilitySystemComponent->GetAvatarActor();

	if (SourceAvatarActor == OtherActor)
		return false;

	if (!UAuraAbilitySystemLibrary::IsNotFriend(SourceAvatarActor, OtherActor))
		return false;

	return true;
}

본인과 아군 대상으로는 데미지를 입힐 수 없도록 함수를 구성한다.

(1-5) 타이머 설정

	FTimerHandle TimerHandle;

void AAuraFireTornado::BeginPlay()
{
	Super::BeginPlay();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// 타이머 설정
	FTimerDelegate TimerDelegate;
	TimerDelegate.BindUFunction(this, FName("ApplyDamageAndKnockback"));

	GetWorldTimerManager().SetTimer(
		TimerHandle,
		TimerDelegate,
		DamageDeltaSecond,
		true
		);
}

데미지 델타 초마다 콜백 함수가 호출되도록 지정한다.

(2) 블루프린트 생성

시간에 따라 제자리 회전하도록 할 것이다.

메시를 추가하고 머티리얼을 반투명한 재질로 변경한다. 이후 나이아가라 시스템을 추가하고 적용한다.

3. 화염 폭풍 게임플레이 어빌리티

(1) C++ 코드

class AAuraFireTornado;

UCLASS()
class AURA_API UAuraFirenado : public UAuraDamageGameplayAbility
{
	GENERATED_BODY()

public:
	virtual FString GetDescription(int32 Level, const UObject* WorldContextObject);
	virtual FString GetNextLevelDescription(int32 Level, const UObject* WorldContextObject);

	UFUNCTION(BlueprintCallable)
	AAuraFireTornado* SpawnTornado();

	UFUNCTION(BlueprintCallable)
	AAuraFireTornado* SpawnTornadoToLocation(const FVector& Location);
	
private:
	UPROPERTY(EditDefaultsOnly)
	TSubclassOf<AAuraFireTornado> FireTornadoClass;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, meta=(AllowPrivateAccess=true))
	float DamageDeltaSecond = 0.2f;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, meta=(AllowPrivateAccess=true))
	float SpawnTime = 5.f;
	
	UPROPERTY(EditDefaultsOnly)
	float FollowRadius = 600.f;
	
	UPROPERTY(EditDefaultsOnly)
	float DamageRadius = 300.f;
};

(1-1) 스펠 설명

FString UAuraFirenado::GetDescription(int32 Level, const UObject* WorldContextObject)
{
	const int32 ScaledDamage = Damage.GetValueAtLevel(Level);
	const float ManaCost = FMath::Abs(GetManaCost(Level));
	const float Cooldown = GetCoolDown(Level);
	const float MagicAttackPower = UAuraAbilitySystemLibrary::GetAttributeValue(WorldContextObject, FAuraGameplayTags::Get().Attributes_Secondary_MagicAttackPower);
	const int32 MagicPowerDamage = MagicAttackPower * MagicPowerCoefficient.GetValue();
	
	return FString::Printf(TEXT(
		"<Title>화염 폭풍</>\n<Small>레벨 </><Level>%d</>\n<Small>마나 </><ManaCost>%.1f</>\n<Small>쿨타임 </><Cooldown>%.1f</>\n<Default>해당 범위에 총 </><Damage>%d</><Default>의 피해를 입히는 화염 기둥을 </><Num>%.1f초</><Default> 동안 소환합니다.</>\n<Small>최대 %.f의 거리에 있는 적을 추적하며, %.f 거리 내의 적에게 데미지를 입힙니다.</>"),
		Level,
		ManaCost,
		Cooldown,
		ScaledDamage + MagicPowerDamage,
		SpawnTime,
		FollowRadius,
		DamageRadius
	);
}

FString UAuraFirenado::GetNextLevelDescription(int32 Level, const UObject* WorldContextObject)
{
	const int32 ScaledDamage = Damage.GetValueAtLevel(Level);
	const float ManaCost = FMath::Abs(GetManaCost(Level));
	const float Cooldown = GetCoolDown(Level);
	const float MagicAttackPower = UAuraAbilitySystemLibrary::GetAttributeValue(WorldContextObject, FAuraGameplayTags::Get().Attributes_Secondary_MagicAttackPower);
	const int32 MagicPowerDamage = MagicAttackPower * MagicPowerCoefficient.GetValue();
	
	return FString::Printf(TEXT(
		"<Title>다음 레벨: </>\n<Small>레벨 </><Level>%d</>\n<Small>마나 </><ManaCost>%.1f</>\n<Small>쿨타임 </><Cooldown>%.1f</>\n<Default>해당 범위에 총 </><Damage>%d</><Default>의 피해를 입히는 화염 기둥을 </><Num>%.1f초</><Default> 동안 소환합니다.</>\n<Small>최대 %.f의 거리에 있는 적을 추적하며, %.f 거리 내의 적에게 데미지를 입힙니다.</>"),
		Level,
		ManaCost,
		Cooldown,
		ScaledDamage + MagicPowerDamage,
		SpawnTime,
		FollowRadius,
		DamageRadius
	);
}

(1-2) 파이어 토네이도 위치에 소환하는 함수

AAuraFireTornado* UAuraFirenado::SpawnTornadoToLocation(const FVector& Location)
{
    FTransform SpawnTransform;
    SpawnTransform.SetLocation(Location);

    // 월드에 파이어볼 생성
    AAuraFireTornado* Tornado = GetWorld()->SpawnActorDeferred<AAuraFireTornado>(
       FireTornadoClass,
       SpawnTransform,
       GetOwningActorFromActorInfo(),
       CurrentActorInfo->PlayerController->GetPawn(),
       ESpawnActorCollisionHandlingMethod::AlwaysSpawn);

    Tornado->SetDamageDeltaSecond(DamageDeltaSecond);
    Tornado->SetFollowRadius(FollowRadius);
    Tornado->SetDamageRadius(DamageRadius);
    
    Tornado->DamageEffectParams = MakeDamageEffectParamsFromClassDefaults();
    Tornado->SetOwner(GetAvatarActorFromActorInfo());

    Tornado->FinishSpawning(SpawnTransform);

    return Tornado;
}

4. 게임플레이 어빌리티 블루프린트

- 클래스 디폴트

파이어 토네이도 클래스를 지정하고 값을 작성한다.

범위 지정 데칼을 사용하기 때문에 Activation Owned Tags에 WaitForExecute 태그를 추가한다.

(1) 범위 지정 데칼 사용 및 오토 런 중지

위의 게임플레이 큐를 적용하면 DA_MessageInfo를 통해 등록된 메시지가 출력된다.

(2) 마우스 액션 검증

마우스 입력, 혹은 어빌리티가 할당된 키가 눌리면 마우스 위치를 저장하고 모션 워핑을 시작한다.

애님 몽타주를 실행한다.

(3) 노티파이 대기 - 토네이도 소환

몽타주 내의 노티파이를 대기하는 노드를 추가하고, 마우스 위치에 토네이도를 소환한다.

(4) 토네이도 위치 조정, 소환 시간 설정, 이펙트 출력, 어빌리티 종료

메인 로직을 설정한다.

(5) EndAbility

어빌리티가 종료될 때 다시 한 번 캐릭터의 오토 런을 중단하고 타이머 핸들을 초기화한다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

32-13. 로그 라이크 - (6) 보스 - (3) 보스 속성 개선, 공격력 개선, 스펠 개선

Crat3 — Thu, 19 Jun 2025 18:39:52 +0900

1. 보스 체력 및 기본 속성(Attributes) 개선

기존에 각 캐릭터 블루프린트의 Attribute Gameplay Effects를 지정해도 반영이 되지 않는 버그가 있었는데, 이는 캐릭터 클래스 인포 데이터 에셋을 참조해서 공용 게임플레이 이펙트를 공유하기 때문이었다. 따라서 아래 부분을 변경한다.

void UAuraAbilitySystemLibrary::InitializeDefaultAttributes(const UObject* WorldContextObject, ECharacterClass CharacterClass, float Level, UAbilitySystemComponent* ASC)
{
	AActor* AvatarActor = ASC->GetAvatarActor();
	AAuraCharacterBase* AvatarCharacter = Cast<AAuraCharacterBase>(AvatarActor);
	
	// 액터의 클래스 정보 가져오기
	UCharacterClassInfo* CharacterClassInfo = GetCharacterClassInfo(AvatarActor);
	if (CharacterClassInfo == nullptr)
		return;

	FCharacterClassDefaultInfo ClassDefaultInfo = CharacterClassInfo->GetClassDefaultInfo(CharacterClass);

	

	// 이펙트 스펙을 위한 컨텍스트 핸들 생성
	FGameplayEffectContextHandle PrimaryAttributesContextHandle = ASC->MakeEffectContext();
	PrimaryAttributesContextHandle.AddSourceObject(AvatarActor);

	FGameplayEffectContextHandle SecondaryAttributesContextHandle = ASC->MakeEffectContext();
	SecondaryAttributesContextHandle.AddSourceObject(AvatarActor);

	FGameplayEffectContextHandle VitalAttributesContextHandle = ASC->MakeEffectContext();
	VitalAttributesContextHandle.AddSourceObject(AvatarActor);

	// 이펙트 적용을 위한 이펙트 스펙 생성 후 적용 - ClassClassInfo가 아닌 클래스 디폴트를 참조하도록 수정됨
	const FGameplayEffectSpecHandle PrimaryAttributesSpecHandle = ASC->MakeOutgoingSpec(AvatarCharacter->DefaultPrimaryAttributes, Level, PrimaryAttributesContextHandle);
	ASC->ApplyGameplayEffectSpecToSelf(*PrimaryAttributesSpecHandle.Data.Get());

	const FGameplayEffectSpecHandle SecondaryAttributesSpecHandle = ASC->MakeOutgoingSpec(AvatarCharacter->DefaultSecondaryAttributes, Level, SecondaryAttributesContextHandle);
	ASC->ApplyGameplayEffectSpecToSelf(*SecondaryAttributesSpecHandle.Data.Get());

	const FGameplayEffectSpecHandle VitalAttributesSpecHandle = ASC->MakeOutgoingSpec(CharacterClassInfo->VitalAttributes, Level, VitalAttributesContextHandle);
	ASC->ApplyGameplayEffectSpecToSelf(*VitalAttributesSpecHandle.Data.Get());
}

이후 보스 전용 PrimaryAttributes 와 SecondaryAttributes 게임플레이 이펙트를 만들어 클래스 디폴트에 세팅한다.

2. 보스 공격력 개선

(1) GE_SecondaryAttributes_Boss_Shaman에서 마법 공격력 계산

(2) GA_EnemyFirebolt / GA_EnemyArcaneShards에 마법 공격력 계수 할당

3. 보스 소환 스펠 개선

보스가 소환수를 소환할 때 플레이어가 맵 끝에 있으면, 공중에 소환수를 소환하게 되어 맵 밖에 소환이 되는 버그가 있다.

TArray<FVector> UAuraSummonAbility::GetSpawnLocations()
{
	const FVector Forward = GetAvatarActorFromActorInfo()->GetActorForwardVector();
	const FVector Location = GetAvatarActorFromActorInfo()->GetActorLocation();

	int Attempt = 0;
	
	const float DeltaSpread = SpawnSpread / NumMinions;
	const FVector LeftSpread = Forward.RotateAngleAxis(-SpawnSpread / 2, FVector::UpVector);
	TArray<FVector> SpawnLocations;

	int idx = 0;
	
	while ( idx < NumMinions )
	{
		const FVector Direction = LeftSpread.RotateAngleAxis(DeltaSpread * idx, FVector::UpVector);
		FVector DirectionVector = Direction * FMath::FRandRange(MinSpawnDistance, MaxSpawnDistance - 50.f * Attempt);
		FVector ChosenSpawnLocation = Location + DirectionVector;

		FHitResult Hit;
			
		if (GetWorld()->LineTraceSingleByChannel(Hit, ChosenSpawnLocation + FVector(0.f, 0.f, 400.f), ChosenSpawnLocation - FVector(0.f, 0.f, 400.f), ECC_Visibility))
		{
			if (Hit.bBlockingHit)
			{
				ChosenSpawnLocation = Hit.ImpactPoint;
				SpawnLocations.Add(ChosenSpawnLocation);
				idx++;
			}
		}
			
		Attempt ++;

		if (Attempt > 15)
			break;
	}
	return SpawnLocations;
}

기존의 for 루프를 while 루프로 대체하고, 라인 트레이스의 불리언 값을 이용해 충돌이 실패했을 때 다시 값을 뽑고, 최대 소환 거리에서 50 * 시도 횟수 만큼의 거리를 빼어 라인 트레이스를 다시 계산한다.

32-12. 로그 라이크 - (6) 보스 - (2) 보스 체력 바

Crat3 — Thu, 19 Jun 2025 17:24:21 +0900

0. 개요

보스 전용 체력 바를 만들고, 전투가 활성화되면 보스의 체력 바를 생성하고 업데이트한다.

1. 보스 체력 바

(1) WBP_EnemyBoss_ProgressBar 생성

기존의 WBP_ProgressBar의 로직을 그대로 복사하여 사용한다.

(2) WBP_EnemyBoss_HealthBar 생성

각 체력 바의 WBP_PictureFrame이 존재하고, 이 이미지를 체력바의 위젯 컨트롤러인 AuraEnemy의 멤버 변수로 추가하고 해당 변수를 가져와 초기화하도록 할 것이다.

	UPROPERTY(EditAnywhere, BlueprintReadOnly)
	TObjectPtr<UTexture> PictureFrameImage;

보스 블루프린트의 클래스 디테일에서 텍스처를 지정한다.

(2-1) Construct 이벤트

기존의 체력 바와는 다르게 작동하기 때문에, 생성된 직후에 체력과 최대 체력을 설정하도록 한다.

이후 체력 변화와 최대 체력 변화 델리게이트를 바인딩한다.

(2-2) 보스 몬스터 사망 시 즉시 위젯 제거

(3) BTS_UpdateBossHealthBar - BT Services 생성

기존의 체력 바 로직은 각 캐릭터의 BeginPlay에서 컴포넌트로 추가 후 체력 변화 델리게이트 호출, 위젯 컨트롤러 바인딩을 수행했다.

이를 BT Services 내부에서 수행한다.

BT Services 내에서 위젯을 생성하여 위젯 컨트롤러를 연결한다.

그리고 뷰 포트에 추가한다.

32-11. 로그 라이크 - (6) 보스 - (1) 비헤이비어 트리 수정, BTTasks 수정, 몬스터 사이 회피(Avoidance) 설정 , 아케인 파편 디버그

Crat3 — Wed, 18 Jun 2025 18:01:54 +0900

0. 개요

기존 몬스터의 AI를 수정하여 보스 형태의 몬스터를 생성한다.

1. 기존의 AI 공격 로직 파악

(1) 엘리멘탈리스트 클래스의 비헤이비어 트리

워리어, 아쳐, 엘리멘탈리스트 3개의 직업군 중, 마법을 활용하는 클래스의 비헤이비어 트리이다.

EQS 쿼리를 사용하여 발사 위치를 계산하고, 공격을 시행하게 되어 있다.

(2) 엘리멘탈리스트 클래스의 공격 태스크

공격 태스크를 살펴보면, 기본적으로 소환한 미니언의 갯수를 체크하여 Minion Spawn Threshold의 갯수보다 미니언의 갯수가 적으면 Summon Tag를 이용하여 GA_Summon 어빌리티를 실행한다.

미니언의 갯수가 적절하면 Ability Tag를 Attack 태그(Abilities.Attack)으로 설정하여, 파이어볼트 공격을 하는 데, 이는 엘리멘탈리스트 직업군 캐릭터인 샤먼 몬스터의 몽타주에서 해당 태그를 전달하고 있기 때문이다.

(3) 엘리멘탈리스트(샤먼)의 공격 몽타주

애님 노티파이가 Montage.Attack.1로 지정되어 있음을 볼 수 있다.

2. 보스 캐릭터 생성

(1) 보스 캐릭터 블루프린트

메시 크기를 크게 설정하고 이에 맞춰 캡슐 크기를 맞춘다.

공격 몽타주를 추가하고 올바른 몽타주 태그를 연결한다.

(2) 몽타주 복제 후 애님 노티파이 변경

사용하게 하려는 어빌리티의 태그와 애님 노티파이의 태그를 일치시킨다.

(3) BTTasks 수정

소환, 아케인 파편 스펠, 파이어 볼트 스펠을 각각의 BT 태스크로 나누고, 비헤이비어 트리를 재구성할 것이다.

(3-1) BTT_Boss_Summon

(3-2) BTT_Boss_ArcaneShards

(3-3) BTT_Boss_FireBolt

(4) 보스 비헤이비어 트리 재구성

하수인 소환, 아케인 파편 스펠, 파이어 볼트 스펠에 대하여 시퀀스 노드를 배치한다.

하수인 소환 어빌리티는 내부적으로 소환수 갯수가 Threshold 이하이면 발동될 것이고, 아케인 파편 스펠은 쿨다운이 존재하므로 쿨다운이 있는 상태에서는 어빌리티가 자동으로 취소될 것이다.

따라서, 일반적인 상황(아케인 파편 스펠 사용 직후, 소환수 일정 마리 이상)에서는 플레이어를 향하여 파이어볼트 공격을 실행하게 된다.

3. 디버그

(1) 소환수와 보스가 아무 동작도 하지 않는 상황

이는 소환수와 보스가 EQS 쿼리를 실행하는 과정에서 획득한 MoveToLocation으로 이동하려고 할 때 서로가 서로의 진로를 방해하기 때문에 발생하는 버그이다.

모든 몬스터 캐릭터 대상으로 RVO 회피 사용을 체크하고, 반경을 적절히 지정한다.

소환수 몬스터의 경우 일정 가중치를 추가 해주면, 보스 몬스터의 움직임을 더 고려하게 된다.

(2) ExecCalc에서 보스가 아케인 파편 스펠로 데미지를 입힐 때 크래시가 발생하는 버그

// 방사형 피해 계산
		if (UAuraAbilitySystemLibrary::IsRadialDamage(EffectContextHandle))
		{
			if (ICombatInterface* CombatInterface = Cast<ICombatInterface>(TargetAvatar))
			{
				CombatInterface->GetOnDamageDelegate().AddLambda([&](float DamageAmount)
					{
						DamageTypeValue = DamageAmount;
						if (CombatInterface)
							CombatInterface->GetOnDamageDelegate().Clear();
					});
			}

			FVector DamageOrigin = UAuraAbilitySystemLibrary::GetRadialDamageOrigin(EffectContextHandle);
			DamageOrigin.Z += 100.f;
			
			UGameplayStatics::ApplyRadialDamageWithFalloff(
				TargetAvatar,
				DamageTypeValue,
				0.f, // 최소 대미지
				DamageOrigin,
				UAuraAbilitySystemLibrary::GetRadialDamageInnerRadius(EffectContextHandle),
				UAuraAbilitySystemLibrary::GetRadialDamageOuterRadius(EffectContextHandle),
				1.f, // 감쇠 계수
				UDamageType::StaticClass(), // 
				TArray<AActor*>(), // IgnoreActor
				SourceAvatar, // DamageCauser
				nullptr); // Controller Instigator
		}

		Damage += DamageTypeValue;
	}

이 코드에서 데미지를 계산하는 ExecCalc 클래스의 계산 함수의 전투 인터페이스의 델리게이트를 바인딩하고 클리어하는 과정에서 댕글링 포인터가 유발되어 크래시가 발생하였다.

이는 여러개의 아케인 파편이 생성되는 과정에서 이전 파편에 플레이어 캐릭터가 사망한 직후, 다음 파편이 방사형 데미지를 계산할 때 널 포인터가 되기 때문이다.

한편으로 위의 코드를 사용한 이유는, 데미지 감쇠를 ApplyRadialDamageWithFalloff 로 계산하고, 해당 데미지를 TakeDamage에서 델리게이트 브로드캐스트로 데미지 양을 전달받아 할당하려 하기 위함이었으나, ExecCalc는 데미지를 계산하는 역할만 해야하고 이외의 어떠한 역할도 하면 안된다(델리게이트 바인딩, 호출 등등).

따라서 코드를 안전하게 리팩토링한다.

(2-1) ExecCalc_Damage - 방사형 데미지 계산

	float CalculateRadialDamage(const AActor* TargetActor, float BaseDamage, const FVector& Origin, float InnerRadius, float OuterRadius, float DamageFalloff) const;

float UExecCalc_Damage::CalculateRadialDamage(const AActor* TargetActor, float BaseDamage, const FVector& Origin, float InnerRadius, float OuterRadius,
	float DamageFalloff) const
{
	FVector TargetLocation = TargetActor->GetActorLocation();

	// 타겟 - 데미지 중심 = 중심에서 타겟까지의 벡터
	FVector DamageVector = TargetLocation - Origin;
	float DistanceToTarget = DamageVector.Length();

	const TRange<float> DistanceRange(InnerRadius, OuterRadius);
	const TRange<float> DamageScaleRange(DamageFalloff, 0.f);

	const float DamageScale = FMath::GetMappedRangeValueClamped(DistanceRange, DamageScaleRange, DistanceToTarget);
	const float Damage = BaseDamage * DamageScale;
	return Damage;
}

방사형 데미지의 변수를 받아 TRange로 만들고, GetMappedRangeValueClamped 함수를 이용하여 퍼센트를 꺼내올 수 있다.

이 함수는 선형 감쇠에 적합하도록 설정되었으므로, 지수형 감쇠를 위하면 리팩토링이 필요하다.

(2-2) 데미지 계산식 수정

		// 속성 저항이 데미지를 퍼센트로 무시함
		DamageTypeValue *= (100.f - Resistance) / 100.f;
		Damage += DamageTypeValue;
		
		// 방사형 피해 계산
		if (UAuraAbilitySystemLibrary::IsRadialDamage(EffectContextHandle))
		{
			Damage = CalculateRadialDamage(
				TargetAvatar,
				DamageTypeValue,
				UAuraAbilitySystemLibrary::GetRadialDamageOrigin(EffectContextHandle),
				UAuraAbilitySystemLibrary::GetRadialDamageInnerRadius(EffectContextHandle),
				UAuraAbilitySystemLibrary::GetRadialDamageOuterRadius(EffectContextHandle),
				1.0f);
		}
	}

방사형 피해를 속성 저항 계산 이후로 보내고, 새로 만든 커스텀 함수를 사용하도록 한다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.