UGA_Skill_Charge 클래스 참조

#include <GA_Skill_Charge.h>

UGA_Skill_Charge에 대한 상속 다이어그램 :

UGA_Skill_Charge에 대한 협력 다이어그램:

Public 멤버 함수
virtual void	ActivateAbility (const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo *ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, const FGameplayEventData *TriggerEventData) override
virtual void	InputReleased (const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo *ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo) override
virtual void	EndAbility (const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo *ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, bool bReplicateEndAbility, bool bWasCancelled) override
UGA_SkillBase(으)로부터 상속된 Public 멤버 함수
const FGameplayTagContainer *	GetCooldownTags () const
UGA_CombatBase(으)로부터 상속된 Public 멤버 함수
virtual void	OnGiveAbility (const FGameplayAbilityActorInfo *ActorInfo, const FGameplayAbilitySpec &Spec) override
UGA_Base(으)로부터 상속된 Public 멤버 함수
	UGA_Base ()

Protected 멤버 함수
virtual void	ApplyCombatData () override
virtual void	ApplyCooldown (const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo *ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo) const override
void	OnPhaseReached (int32 InPhase)
void	ApplyChargePhaseEffects (int32 PhaseIndex)
void	ExecuteInstantAttack ()
void	CleanupTasks ()
void	ClearChargeState ()
void	StartChargeLoopAudio ()
void	StopChargeLoopAudio ()
void	ToNextPhaseState (int32 InPhase)
void	OnMaxPhaseTimeout ()
UGA_SkillBase(으)로부터 상속된 Protected 멤버 함수
virtual bool	CheckCost (const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo *ActorInfo, FGameplayTagContainer *OptionalRelevantTags) const override
virtual void	ApplyCost (const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo *ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo) const override
float	GetSkillMontageSectionLength (const UAnimMontage *Montage, FName SectionName, bool bApplyPlayRate=false, float PlayRate=1.0f) const
bool	HasClearStrikePath (const AMainPlayerCharacter *Player, const AActor *TargetActor) const
void	SetAvatarPawnCollisionResponse (ECollisionResponse Response) const
float	GetPlayerCurrentWeaponAttackRange () const
void	SetAvatarMeshHidden (bool bHidden) const
void	ResetSkillMontagePlayRate () const
AActor *	GetTargetActor () const
UAnimMontage *	GetSkillMontage (FGameplayTag PlayMontageTag=FGameplayTag::EmptyTag) const
bool	ContainsAllMontageSections (const UAnimMontage *Montage, TArray< FName > SectionNames) const
template<typename T >
const T *	GetExtendedData () const
template<typename T >
bool	HasExtendedData () const
UGA_CombatBase(으)로부터 상속된 Protected 멤버 함수
void	SetupHitCheckListener ()
void	OnHitCheckStart (FGameplayEventData Payload)
void	OnHitCheckEnd (FGameplayEventData Payload)
void	OnTraceResultCallback (const FGameplayAbilityTargetDataHandle &TargetDataHandle, float CombatDataLevel, int32 CombatHitDataIndex)
void	OnFinisherResultCallback (const FGameplayAbilityTargetDataHandle &TargetDataHandle, float CombatDataLevel, int32 CombatHitDataIndex)
virtual TOptional< FTransform >	GetTraceTransformForHitCheck () const
void	ApplyEffectsToSelf (const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo *ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo)
FCombatHitPayload	BuildCombatHitPayload (const FCombatHitData &HitData, float DamageMultiplier, bool bRequestKnockback)
TArray< FGameplayEffectSpecHandle >	BuildCombatEffectSpecs (const FCombatHitData &HitData, float DamageMultiplier)
FGameplayEffectSpecHandle	BuildEffectSpec (const FCombatEffectData &EffectData, float CombatDataLevel)
void	PlayCombatHitAudio (const FVector &HitLocation)
void	CacheAudioTagComponents ()
const FKnockbackData *	FindKnockbackData (const FCombatHitData &HitData) const
void	NotifyCameraHitConfirmed () const
float	GetAttackSpeedRate () const
void	UpdateAttackWarpTargetForRange (FName WarpTargetName=FName("Target"))
void	UpdateAttackWarpTargetForRange (FName WarpTargetName, ITargetableInterface *Target)
UGA_Base(으)로부터 상속된 Protected 멤버 함수
UCharacterMotionWarpingComponentBase *	GetMotionWarpingComponent () const
void	SetupCancelableListener ()
void	OnCancelableInputDetected (FGameplayEventData Payload)
virtual void	HandleCancelable (FGameplayEventData Payload)
virtual void	OnAbilityMontageCompleted ()
virtual void	OnAbilityMontageInterrupted ()
virtual void	OnAbilityMontageCancellable ()

Protected 속성
TSubclassOf< UGameplayEffect >	ChargeSlowEffectClass
float	MaxPhaseDuration = 5.0f
FTimerHandle	MaxPhaseTimeoutTimer
FActiveGameplayEffectHandle	ActiveSlowEffectHandle
TObjectPtr< UDataTable >	ChargePhaseTable
TArray< TObjectPtr< UAnimMontage > >	AttackMontages
FGameplayTag	ChargeLoopAudioTag
TArray< FChargePhaseTableRow >	CachedPhaseRows
int32	CurrentPhase = 0
TArray< FTimerHandle >	PhaseDelayTimers
bool	bChargeStateActive = false
bool	bShouldApplyCooldownOnEnd = false
UGA_SkillBase(으)로부터 상속된 Protected 속성
FGameplayTag	CooldownTag
float	CostValue
float	CooldownDuration
UGA_CombatBase(으)로부터 상속된 Protected 속성
TObjectPtr< UCombatDataBase >	CombatData
float	AttackRange = 450.0f
float	AttackRangeCorrectionDistance = 250.0f
float	AttackRangeCorrectionInnerOffset = 30.0f
TObjectPtr< UAT_Trace >	ActiveTraceTask
TArray< TSubclassOf< UGameplayEffect > >	SelfEffectClasses
FGameplayTag	WeaponHitCueTag
TArray< TObjectPtr< UAudioEmitterComponent > >	CachedAudioTagComponents

멤버 함수 문서화

ActivateAbility()

void UGA_Skill_Charge::ActivateAbility ( const FGameplayAbilitySpecHandle  Handle, const FGameplayAbilityActorInfo *  ActorInfo, const FGameplayAbilityActivationInfo  ActivationInfo, const FGameplayEventData *  TriggerEventData  )

overridevirtual

UGA_SkillBase(으)로부터 재구현되었습니다.

{
    // Super(UGA_SkillBase) 미호출 의도: 차지 스킬은 표준 SkillBase 흐름(즉시 몽타주 재생, 회전, 히트체크 세팅)을 사용하지 않음. 단계별 몽타주는 ExecuteInstantAttack 시점에 재생.
    ACharacter* Character = Cast<ACharacter>(ActorInfo->AvatarActor.Get());
    if (!Character)
    {
        EndAbility(Handle, ActorInfo, ActivationInfo, false, true);
        return;
    }
 
    UAbilitySystemComponent* ASC = GetAbilitySystemComponentFromActorInfo();
 
    if (!ASC)
    {
        EndAbility(Handle, ActorInfo, ActivationInfo, false, true);
        return;
    }
 
    if (!ChargePhaseTable)
    {
        LOG_ERROR(LogCK, "Charge 테이블 비어 있음。");
        EndAbility(Handle, ActorInfo, ActivationInfo, false, true);
        return;
    }
 
    if (AttackMontages.Num() == 0)
    {
        LOG_ERROR(LogCK, "Charge 스킬 InstantAttackMontages 배열이 비어있음");
        EndAbility(Handle, ActorInfo, ActivationInfo, false, true);
        return;
    }
 
    if (!CommitAbility(Handle, ActorInfo, ActivationInfo))
    {
        EndAbility(Handle, ActorInfo, ActivationInfo, true, true);
        return;
    }
    
    bShouldApplyCooldownOnEnd = true;
 
    IChargeInterface* ChargeInterface = Cast<IChargeInterface>(GetAvatarActorFromActorInfo());
    if (ChargeInterface)
    {
        ChargeInterface->OnChargeBegin();
    }
 
    ApplyEffectsToSelf(Handle, ActorInfo, ActivationInfo);
    
    // 캔슬 준비
    SetupCancelableListener();
    
    ASC->AddGameplayCue(TAG_CUE_CHARGE_AURA); // 차지 아우라 이펙트 Cue 전송
    ASC->AddLooseGameplayTag(TAG_CHARACTER_STATE_COMBAT_ISCHARGING); // 차지 태그 (ABP) 적용
    bChargeStateActive = true;
    StartChargeLoopAudio();
 
    // 차지 단계 데이터 스냅샷
    CachedPhaseRows.Reset();
    TArray<FChargePhaseTableRow*> Rows;
    ChargePhaseTable->GetAllRows(TEXT("ChargePhaseContext"), Rows);
    for (FChargePhaseTableRow* R : Rows)
    {
        if (R)
        {
            CachedPhaseRows.Add(*R);
        }
    }
    CachedPhaseRows.Sort([](const FChargePhaseTableRow& A, const FChargePhaseTableRow& B)
    {
        return A.Charge_Time < B.Charge_Time;
    });
 
    if (CachedPhaseRows.Num() == 0)
    {
        LOG_ERROR(LogCK, "ChargePhaseTable이 비어있음");
        EndAbility(Handle, ActorInfo, ActivationInfo, false, true);
        return;
    }
 
    CurrentPhase = 0;
 
    // 단계별 길이 배열 계산 — Charge_Time은 누적 시간이므로 차분
    TArray<float> PhaseDurations;
    PhaseDurations.Reserve(CachedPhaseRows.Num());
 
    float PrevTime = 0.0f;
    for (const FChargePhaseTableRow& Row : CachedPhaseRows)
    {
        const float Duration = FMath::Max(Row.Charge_Time - PrevTime, 0.0f);
        PhaseDurations.Add(Duration);
        PrevTime = Row.Charge_Time;
    }
 
    UWorld* World = GetWorld();
    if (!World)
    {
        EndAbility(Handle, ActorInfo, ActivationInfo, false, true);
        return;
    }
 
    FTimerManager& TimerManager = World->GetTimerManager();
 
    for (int32 i = 0; i < CachedPhaseRows.Num(); ++i)
    {
        const float Time = CachedPhaseRows[i].Charge_Time;
        if (Time <= 0.f)
        {
            continue;
        }
 
        const int32 PhaseNumber = i + 1;
        FTimerHandle Handle_Phase;
        TimerManager.SetTimer(Handle_Phase, FTimerDelegate::CreateUObject(this, &ThisClass::OnPhaseReached, PhaseNumber), Time, false);
        PhaseDelayTimers.Add(Handle_Phase);
    }
 
    // 초기 단계 데이터 적용
    ApplyChargePhaseEffects(0);
 
    // State 컴포넌트에 차지 시작 통지
    if (ChargeInterface)
    {
        if (UChargeStateComponent* StateComp = ChargeInterface->GetChargeStateComponent())
        {
            StateComp->BeginCharge(PhaseDurations);
        }
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

ApplyChargePhaseEffects()

void UGA_Skill_Charge::ApplyChargePhaseEffects ( int32  PhaseIndex )

protected

{
    if (!CachedPhaseRows.IsValidIndex(PhaseIndex))
    {
        return;
    }
 
    const FChargePhaseTableRow& Row = CachedPhaseRows[PhaseIndex];
 
    UAbilitySystemComponent* ASC = GetAbilitySystemComponentFromActorInfo();
    if (!ASC)
    {
        return;
    }
    
    if (ChargeSlowEffectClass)
    {
        // 기존 슬로우 GE 제거 
        if (ActiveSlowEffectHandle.IsValid())
        {
            ASC->RemoveActiveGameplayEffect(ActiveSlowEffectHandle);
            ActiveSlowEffectHandle.Invalidate();
        }
 
        FGameplayEffectContextHandle EffectContext = ASC->MakeEffectContext();
        EffectContext.AddSourceObject(this);
 
        FGameplayEffectSpecHandle SpecHandle = ASC->MakeOutgoingSpec(ChargeSlowEffectClass, 1.0f, EffectContext);
        if (SpecHandle.IsValid())
        {
            SpecHandle.Data->SetSetByCallerMagnitude(TAG_DATA_STAT_MOVE_SPEED, Row.Move_Speed);
            ActiveSlowEffectHandle = ASC->ApplyGameplayEffectSpecToSelf(*SpecHandle.Data.Get());
            LOG_INFO(LogCKAttribute, "Charge Phase[%d] Move_Speed=%.2f 적용", PhaseIndex, Row.Move_Speed);
        }
    }
 
    // Rot_Speed 전달
    if (IChargeInterface* ChargeInterface = Cast<IChargeInterface>(GetAvatarActorFromActorInfo()))
    {
        ChargeInterface->OnChargePhaseChanged(Row.Rot_Speed);
    }
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ApplyCombatData()

void UGA_Skill_Charge::ApplyCombatData ( )

overrideprotectedvirtual

UGA_SkillBase(으)로부터 재구현되었습니다.

{
    Super::ApplyCombatData();
 
    if (!CombatData)
    {
        return;
    }
 
    if (const FSkillChargeDatas* Payload = CombatData->FindExtendedData<FSkillChargeDatas>())
    {
        ChargePhaseTable = Payload->ChargePhaseDataTable;
        AttackMontages = Payload->AttackMontages;
        ChargeLoopAudioTag = Payload->ChargeLoopAudioTag;
    }
}

ApplyCooldown()

void UGA_Skill_Charge::ApplyCooldown ( const FGameplayAbilitySpecHandle  Handle, const FGameplayAbilityActorInfo *  ActorInfo, const FGameplayAbilityActivationInfo  ActivationInfo  ) const

overrideprotectedvirtual

UGA_SkillBase(으)로부터 재구현되었습니다.

{
    if (!bShouldApplyCooldownOnEnd)
    {
        return;
    }
    
    Super::ApplyCooldown(Handle, ActorInfo, ActivationInfo);
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

CleanupTasks()

void UGA_Skill_Charge::CleanupTasks ( )

protected

{
    if (IChargeInterface* ChargeInterface = Cast<IChargeInterface>(GetAvatarActorFromActorInfo()))
    {
        ChargeInterface->OnChargeEnd();
    }
 
    ClearChargeState();
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ClearChargeState()

void UGA_Skill_Charge::ClearChargeState ( )

protected

{
    if (UWorld* World = GetWorld())
    {
        FTimerManager& TimerManager = World->GetTimerManager();
        for (FTimerHandle& Handle_Phase : PhaseDelayTimers)
        {
            TimerManager.ClearTimer(Handle_Phase);
        }
        TimerManager.ClearTimer(MaxPhaseTimeoutTimer);
    }
    PhaseDelayTimers.Empty();
 
    StopChargeLoopAudio();
 
    if (!bChargeStateActive)
    {
        return;
    }
 
    bChargeStateActive = false;
 
    UAbilitySystemComponent* ASC = GetAbilitySystemComponentFromActorInfo();
    if (!ASC)
    {
        return;
    }
 
    ASC->RemoveGameplayCue(TAG_CUE_CHARGE_AURA);
    ASC->RemoveLooseGameplayTag(TAG_CHARACTER_STATE_COMBAT_ISCHARGING);
 
    if (ActiveSlowEffectHandle.IsValid())
    {
        ASC->RemoveActiveGameplayEffect(ActiveSlowEffectHandle);
        ActiveSlowEffectHandle.Invalidate();
        LOG_INFO(LogCKAttribute, "MoveSpeedSlow 해제!!!");
    }
 
    // State 컴포넌트에 차지 종료 통지
    if (IChargeInterface* ChargeIface = Cast<IChargeInterface>(GetAvatarActorFromActorInfo()))
    {
        if (UChargeStateComponent* StateComp = ChargeIface->GetChargeStateComponent())
        {
            StateComp->EndCharge();
        }
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

EndAbility()

void UGA_Skill_Charge::EndAbility ( const FGameplayAbilitySpecHandle  Handle, const FGameplayAbilityActorInfo *  ActorInfo, const FGameplayAbilityActivationInfo  ActivationInfo, bool  bReplicateEndAbility, bool  bWasCancelled  )

overridevirtual

UGA_CombatBase(으)로부터 재구현되었습니다.

{
    if (bShouldApplyCooldownOnEnd)
    {
        ApplyCooldown(Handle, ActorInfo, ActivationInfo);
    }
    
    bShouldApplyCooldownOnEnd = false;
    CurrentPhase = 0;
 
    CleanupTasks();
    Super::EndAbility(Handle, ActorInfo, ActivationInfo, bReplicateEndAbility, bWasCancelled);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ExecuteInstantAttack()

void UGA_Skill_Charge::ExecuteInstantAttack ( )

protected

{
    // 1단계 도달 전 바로 종료
    if (CurrentPhase == 0)
    {
        EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, false);
        return;
    }
 
    ClearChargeState();
 
    UAbilitySystemComponent* ASC = GetAbilitySystemComponentFromActorInfo();
    if (!ASC)
    {
        return;
    }
 
    // 몽타주 불러오기
    const int32 Index = FMath::Clamp(CurrentPhase - 1, 0, AttackMontages.Num() - 1);
    UAnimMontage* MontageToPlay = AttackMontages[Index];
 
    if (!MontageToPlay)
    {
        EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, true);
        return;
    }
 
    SetupHitCheckListener();
 
    // 몽타주 재생
    UAbilityTask_PlayMontageAndWait* Task = UAbilityTask_PlayMontageAndWait::CreatePlayMontageAndWaitProxy(this, TEXT("ChargeAttack"), MontageToPlay, 1.0f);
    if (!Task)
    {
        EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, true);
        return;
    }
 
    Task->OnCompleted.AddDynamic(this, &ThisClass::OnAbilityMontageCompleted);
    Task->OnInterrupted.AddDynamic(this, &ThisClass::OnAbilityMontageInterrupted);
    Task->ReadyForActivation();
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

InputReleased()

void UGA_Skill_Charge::InputReleased ( const FGameplayAbilitySpecHandle  Handle, const FGameplayAbilityActorInfo *  ActorInfo, const FGameplayAbilityActivationInfo  ActivationInfo  )

overridevirtual

{
    ExecuteInstantAttack();
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

OnMaxPhaseTimeout()

void UGA_Skill_Charge::OnMaxPhaseTimeout ( )

protected

{
    LOG_INFO(LogCK, "Charge MaxPhase 유지시간 초과 — 어빌리티 취소");
    CancelAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true);
}

OnPhaseReached()

void UGA_Skill_Charge::OnPhaseReached ( int32  InPhase )

protected

{
    CurrentPhase = InPhase;
    LOG_INFO(LogCK, "Charge Phase %d", CurrentPhase);
    ToNextPhaseState(CurrentPhase);
 
    // 마지막 단계 도달 시 유지 가능한 시간 초과하면 자동 취소 
    if (CurrentPhase == CachedPhaseRows.Num())
    {
        if (UWorld* World = GetWorld())
        {
            World->GetTimerManager().SetTimer(MaxPhaseTimeoutTimer,this, &ThisClass::OnMaxPhaseTimeout,MaxPhaseDuration,false);
        }
        return;
    }
 
    ApplyChargePhaseEffects(InPhase);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

StartChargeLoopAudio()

void UGA_Skill_Charge::StartChargeLoopAudio ( )

protected

{
    if (ChargeLoopAudioTag.IsValid() == false)
    {
        return;
    }
 
    if (CachedAudioTagComponents.IsEmpty())
    {
        CacheAudioTagComponents();
    }
 
    for (UAudioEmitterComponent* AudioTagComponent : CachedAudioTagComponents)
    {
        if (AudioTagComponent == nullptr)
        {
            continue;
        }
 
        if (AudioTagComponent->StartLoopAudioTag(ChargeLoopAudioTag))
        {
            return;
        }
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

StopChargeLoopAudio()

void UGA_Skill_Charge::StopChargeLoopAudio ( )

protected

{
    if (ChargeLoopAudioTag.IsValid() == false)
    {
        return;
    }
 
    if (CachedAudioTagComponents.IsEmpty())
    {
        CacheAudioTagComponents();
    }
 
    for (UAudioEmitterComponent* AudioTagComponent : CachedAudioTagComponents)
    {
        if (AudioTagComponent == nullptr)
        {
            continue;
        }
 
        AudioTagComponent->StopLoopAudioTag(ChargeLoopAudioTag);
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ToNextPhaseState()

void UGA_Skill_Charge::ToNextPhaseState ( int32  InPhase )

protected

{
    if (IChargeInterface* ChargeInterface = Cast<IChargeInterface>(GetAvatarActorFromActorInfo()))
    {
        if (UChargeStateComponent* StateComp = ChargeInterface->GetChargeStateComponent())
        {
            StateComp->ChangePhase(InPhase);
        }
    }
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

ActiveSlowEffectHandle

FActiveGameplayEffectHandle UGA_Skill_Charge::ActiveSlowEffectHandle

protected

AttackMontages

TArray<TObjectPtr<UAnimMontage> > UGA_Skill_Charge::AttackMontages

protected

bChargeStateActive

bool UGA_Skill_Charge::bChargeStateActive = false

protected

bShouldApplyCooldownOnEnd

bool UGA_Skill_Charge::bShouldApplyCooldownOnEnd = false

protected

CachedPhaseRows

TArray<FChargePhaseTableRow> UGA_Skill_Charge::CachedPhaseRows

protected

ChargeLoopAudioTag

FGameplayTag UGA_Skill_Charge::ChargeLoopAudioTag

protected

ChargePhaseTable

TObjectPtr<UDataTable> UGA_Skill_Charge::ChargePhaseTable

protected

ChargeSlowEffectClass

TSubclassOf<UGameplayEffect> UGA_Skill_Charge::ChargeSlowEffectClass

protected

CurrentPhase

int32 UGA_Skill_Charge::CurrentPhase = 0

protected

MaxPhaseDuration

float UGA_Skill_Charge::MaxPhaseDuration = 5.0f

protected

MaxPhaseTimeoutTimer

FTimerHandle UGA_Skill_Charge::MaxPhaseTimeoutTimer

protected

PhaseDelayTimers

TArray<FTimerHandle> UGA_Skill_Charge::PhaseDelayTimers

protected

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• Source/CK_UE/GAS/GA/GA_Skill/GA_Skill_Charge.h
• Source/CK_UE/GAS/GA/GA_Skill/GA_Skill_Charge.cpp