AMainPlayerCharacter 클래스 참조

#include <MainPlayerCharacter.h>

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

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

Public 멤버 함수
	AMainPlayerCharacter (const FObjectInitializer &ObjectInitializer=FObjectInitializer::Get())
virtual void	OnChargeBegin () override
virtual void	OnChargeEnd () override
virtual void	OnChargePhaseChanged (float RotSpeedMul) override
virtual void	CacheAttackContext () override
virtual UChargeStateComponent *	GetChargeStateComponent () const override
virtual bool	HasTargetingTarget (ETargetingMode) override
UCameraZoomComponent *	GetCameraDistanceComponent () const
UCameraTargetingComponent *	GetPlayerTargetingComponent () const
void	RespawnAtTransform (const FTransform &RespawnTransform)
FORCEINLINE UTargetingComponent *	GetTargetingComponent () const
FORCEINLINE UPlayerMotionWarpingComponent *	GetMotionWarpingComponent () const
FORCEINLINE FVector	GetRawMovementInputDirection () const
FORCEINLINE UInputMappingContext *	GetDefaultMappingContext () const
FORCEINLINE UPlayerMovementComponent *	GetPlayerMovementComponent () const
FORCEINLINE UProjectileLauncherComponent *	GetProjectileLauncherComponent () const
FORCEINLINE UWeaponLoadoutComponent *	GetWeaponLoadoutComponent () const
FORCEINLINE FGameplayTag	GetDefaultWeaponTag () const
FORCEINLINE USkeletalMeshComponent *	GetWeaponMeshComponent () const
FORCEINLINE APlayerController *	GetPlayerController () const
FORCEINLINE UCharacterGhostEffectComponent *	GetCharacterGhostWarpEffectComponent () const
ACharacterBase(으)로부터 상속된 Public 멤버 함수
	ACharacterBase (const FObjectInitializer &ObjectInitializer=FObjectInitializer::Get())
virtual bool	IsDead () const
virtual void	PlayDeadAnimation ()
bool	IsStaggerImmune () const
virtual class UAbilitySystemComponent *	GetAbilitySystemComponent () const override
FORCEINLINE FOnAbilitySystemReady &	GetOnAbilitySystemReady ()
FORCEINLINE UKnockbackComponent *	GetKnockbackComponent () const

Public 속성
const FPlayerExtendedData *	PlayerExtendedData = nullptr

Protected 멤버 함수
virtual void	SetupPlayerInputComponent (UInputComponent *PlayerInputComponent) override
virtual void	PossessedBy (AController *NewController) override
virtual void	PostInitializeComponents () override
virtual void	BeginPlay () override
virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override
void	InitializePlayerControllerDependencies (APlayerController *PlayerController)
void	GASInputPressed (FGameplayTag InputTag)
void	GASInputReleased (FGameplayTag InputTag)
FGameplayAbilitySpec *	FindAbilitySpecByInputTag (const FGameplayTag &InputTag) const
void	RotateCamera (const FInputActionValue &Value)
void	OnMouseWheel (const FInputActionValue &Value)
void	ToggleLockOn ()
void	Move (const FInputActionValue &Value)
void	OnMoveStarted (const FInputActionValue &Value)
bool	CanMove () const
void	OnTargetingChanged (bool bActive)
void	ChangeAimState ()
void	BeginChargeFacingTurn ()
void	UpdateChargeFacingTurn ()
virtual void	OnDeath ()
virtual void	SetDead () override
virtual void	InitializeAttributes () override
virtual void	OnDamageTaken (const FDamageResultData &DamageResult) override
virtual UAnimMontage *	GetHitReactMontage () const override
void	ApplyDamageTakenEffect ()
void	OnAnyGameplayEffectApplied (UAbilitySystemComponent *SourceASC, const FGameplayEffectSpec &Spec, FActiveGameplayEffectHandle)
bool	RecordHitStun ()
void	TriggerKnockDown (UAbilitySystemComponent *SourceASC, const FGameplayEffectSpec &Spec)
void	ResetHitStunTimes ()
void	OnHitStunTagChanged (const FGameplayTag CallbackTag, int32 NewCount)
ACharacterBase(으)로부터 상속된 Protected 멤버 함수
virtual void virtual InitializeAttributes() PURE_VIRTUAL(ACK_CharacterBase void	OnMoveSpeedChanged (const struct FOnAttributeChangeData &Data)
bool	CanPlayHitReaction (const FDamageResultData &DamageResult) const
void	PlayHitReaction (AActor *Attacker)
virtual void	RotateHitSource (const FVector &HitFromLocation)
virtual void	OnHitReactMontageEnded (UAnimMontage *Montage, bool bInterrupted)

Protected 속성
TObjectPtr< UPlayerMotionWarpingComponent >	MotionWarpingComponent
TObjectPtr< UTargetingComponent >	TargetingComponent
TObjectPtr< UPlayerMovementComponent >	PlayerMovementComponent
TObjectPtr< UChargeStateComponent >	ChargeStateComponent
TObjectPtr< UProjectileLauncherComponent >	ProjectileLauncherComponent
TObjectPtr< UWeaponLoadoutComponent >	WeaponLoadoutComponent
TObjectPtr< USkeletalMeshComponent >	WeaponMesh
TObjectPtr< UCharacterGhostEffectComponent >	CharacterGhostEffectComponent
TObjectPtr< UCharacterControlData >	CharacterControlData
bool	bPlayerControllerDependenciesInitialized = false
ACharacterBase(으)로부터 상속된 Protected 속성
FOnAbilitySystemReady	OnAbilitySystemReady
TObjectPtr< UAbilitySystemComponent >	ASC
TObjectPtr< UKnockbackComponent >	KnockbackComponent
TObjectPtr< UAudioEmitterComponent >	AudioTagComponent

Private 속성
float	LookSensitivity = 1.0f
bool	bIsCharging = false
bool	bIsLockedOn = false
float	ChargeFacingTargetYaw = 0.0f
float	ChargeFacingTurnTolerance = 1.0f
FTimerHandle	ChargeFacingTurnTimerHandle
FVector	RawMovementInputDirection = FVector::ZeroVector
uint64	RawMovementInputFrame = 0
TArray< double >	RecentHitStunTimes
FDelegateHandle	HitStunTagDelegateHandle
FDelegateHandle	GEAppliedDelegateHandle

생성자 & 소멸자 문서화

AMainPlayerCharacter()

AMainPlayerCharacter::AMainPlayerCharacter

(

const FObjectInitializer &

ObjectInitializer = FObjectInitializer::Get()

)

                                                                                      : Super(ObjectInitializer.SetDefaultSubobjectClass<UPlayerMovementComponent>(CharacterMovementComponentName))
{
    //Player State 클래스에서 명시적으로 할당함. 
    ASC = nullptr;
    PlayerMovementComponent = CastChecked<UPlayerMovementComponent>(GetCharacterMovement());
    PlayerMovementComponent->BrakingDecelerationWalking = 800.0f;
 
    CharacterGhostEffectComponent = CreateDefaultSubobject<UCharacterGhostEffectComponent>(TEXT("CharacterGhostEffectComponent"));
    ProjectileLauncherComponent = CreateDefaultSubobject<UProjectileLauncherComponent>(TEXT("ProjectileLauncherComponent"));
    MotionWarpingComponent = CreateDefaultSubobject<UPlayerMotionWarpingComponent>(TEXT("MotionWarpingComponent"));
    WeaponLoadoutComponent = CreateDefaultSubobject<UWeaponLoadoutComponent>(TEXT("WeaponLoadoutComponent"));
    ChargeStateComponent = CreateDefaultSubobject<UChargeStateComponent>(TEXT("ChargeStateComponent"));
    TargetingComponent = CreateDefaultSubobject<UTargetingComponent>(TEXT("TargetingComponent"));
    WeaponMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("WeaponMeshComponent"));
 
    WeaponMesh->SetupAttachment(GetMesh());
    WeaponMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    WeaponMesh->SetAnimationMode(EAnimationMode::AnimationBlueprint);
    WeaponMesh->SetHiddenInGame(true);
    WeaponMesh->SetReceivesDecals(false);
 
    GetCharacterMovement()->bOrientRotationToMovement = true;
    GetCapsuleComponent()->SetCollisionProfileName(CPROFILE_CKPLAYERCAPSULE);
}

멤버 함수 문서화

ApplyDamageTakenEffect()

void AMainPlayerCharacter::ApplyDamageTakenEffect ( )

protected

{
    if (PlayerExtendedData == nullptr || PlayerExtendedData->DamageTakenEffectClass == nullptr)
    {
        return;
    }
 
    const FGameplayEffectContextHandle EffectContext = ASC->MakeEffectContext();
    const FGameplayEffectSpecHandle SpecHandle = ASC->MakeOutgoingSpec(PlayerExtendedData->DamageTakenEffectClass,1.0f, EffectContext);
 
    if (SpecHandle.IsValid() == false)
    {
        return;
    }
    
    ASC->ApplyGameplayEffectSpecToSelf(*SpecHandle.Data.Get());
}

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

BeginChargeFacingTurn()

void AMainPlayerCharacter::BeginChargeFacingTurn ( )

protected

{
    UCharacterMovementComponent* MovementComp = GetCharacterMovement();
    if (MovementComp == nullptr)
    {
        return;
    }
 
    MovementComp->bOrientRotationToMovement = false;
    MovementComp->bUseControllerDesiredRotation = false;
 
    // 락온이면 타겟 방향, 아니면 카메라 정면
    float TargetYaw = GetActorRotation().Yaw;
    bool bResolved = false;
 
    if (bIsLockedOn)
    {
        const UCameraTargetingComponent* TargetingComp = GetPlayerTargetingComponent();
        const AActor* TargetActor = ITargetableInterface::AsActor(TargetingComp ? TargetingComp->GetCurrentTarget().GetInterface() : nullptr);
        const FVector ToTarget = TargetActor ? TargetActor->GetActorLocation() - GetActorLocation() : FVector::ZeroVector;
 
        if (!ToTarget.IsNearlyZero())
        {
            bResolved = true;
            TargetYaw = ToTarget.Rotation().Yaw;
        }
    }
 
    if (!bResolved)
    {
        if (const AController* OwnerController = GetController())
        {
            TargetYaw = OwnerController->GetControlRotation().Yaw;
        }
    }
 
    ChargeFacingTargetYaw = TargetYaw;
 
    if (FMath::Abs(FRotator::NormalizeAxis(ChargeFacingTargetYaw - GetActorRotation().Yaw)) <= ChargeFacingTurnTolerance)
    {
        return;
    }
 
    if (UWorld* World = GetWorld())
    {
        World->GetTimerManager().SetTimer(ChargeFacingTurnTimerHandle, this, &ThisClass::UpdateChargeFacingTurn, 0.01f, true);
    }
}

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

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

BeginPlay()

void AMainPlayerCharacter::BeginPlay ( )

overrideprotectedvirtual

{
    Super::BeginPlay();
 
    InitializePlayerControllerDependencies(Cast<APlayerController>(GetController()));
}

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

CacheAttackContext()

void AMainPlayerCharacter::CacheAttackContext ( )

overridevirtual

IAttackableInterface를 구현.

{
    const FVector Velocity = PlayerMovementComponent->Velocity;
    const FVector SurfaceVelocity(Velocity.X, Velocity.Y, 0.0f);
    PlayerMovementComponent->SetExtraVelocity(SurfaceVelocity.GetClampedToMaxSize2D(PlayerMovementComponent->GetWalkSpeed()));
}

CanMove()

bool AMainPlayerCharacter::CanMove ( ) const

protected

{
    return ASC && ASC->HasMatchingGameplayTag(TAG_CHARACTER_STATE_ISBLOCKMOVEMENT) == false;
}

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

ChangeAimState()

void AMainPlayerCharacter::ChangeAimState ( )

protected

{
    // 차지 또는 락온 상태에서는 린(Lean)을 비활성화
    const bool bShouldDisableLean = bIsCharging || bIsLockedOn;
    UPlayerMovementComponent* PlayerMovement = GetPlayerMovementComponent();
 
    if (PlayerMovement == nullptr)
    {
        return;
    }
 
    PlayerMovement->SetLeaningEnabled(bShouldDisableLean == false);
}

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

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

EndPlay()

void AMainPlayerCharacter::EndPlay ( const EEndPlayReason::Type  EndPlayReason )

overrideprotectedvirtual

{
    if (ASC)
    {
        if (const UPlayerAttributeSet* CurrentAttributeSet = ASC->GetSet<UPlayerAttributeSet>())
        {
            CurrentAttributeSet->OnDeathDelegate.RemoveDynamic(this, &ThisClass::OnDeath);
            CurrentAttributeSet->OnDamageDelegate.RemoveAll(this);
        }
 
        if (HitStunTagDelegateHandle.IsValid())
        {
            ASC->UnregisterGameplayTagEvent(HitStunTagDelegateHandle, TAG_CHARACTER_STATE_ISHITSTUN, EGameplayTagEventType::NewOrRemoved);
            HitStunTagDelegateHandle.Reset();
        }
 
        if (GEAppliedDelegateHandle.IsValid())
        {
            ASC->OnGameplayEffectAppliedDelegateToSelf.Remove(GEAppliedDelegateHandle);
            GEAppliedDelegateHandle.Reset();
        }
    }
 
    Super::EndPlay(EndPlayReason);
}

FindAbilitySpecByInputTag()

FGameplayAbilitySpec * AMainPlayerCharacter::FindAbilitySpecByInputTag ( const FGameplayTag &  InputTag ) const

protected

{
    if (ASC == nullptr || InputTag.IsValid() == false)
    {
        return nullptr;
    }
 
    for (const FGameplayAbilitySpec& Spec : ASC->GetActivatableAbilities())
    {
        FGameplayTagContainer Container = Spec.GetDynamicSpecSourceTags();
 
        if (Container.IsEmpty())
        {
            continue;
        }
 
        if (Container.HasTagExact(InputTag))
        {
            return ASC->FindAbilitySpecFromHandle(Spec.Handle);
        }
    }
 
    return nullptr;
}

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

GASInputPressed()

void AMainPlayerCharacter::GASInputPressed ( FGameplayTag  InputTag )

protected

{
    if (ASC == nullptr || ASC->HasMatchingGameplayTag(TAG_CHARACTER_STATE_ISBLOCKINPUT))
    {
        return;
    }
 
    FGameplayAbilitySpec* Spec = FindAbilitySpecByInputTag(InputTag);
 
    if (Spec == nullptr)
    {
        return;
    }
 
    Spec->InputPressed = true;
 
    if (Spec->IsActive())
    {
        ASC->AbilitySpecInputPressed(*Spec);
    }
    else
    {
        ASC->TryActivateAbility(Spec->Handle);
    }
}

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

GASInputReleased()

void AMainPlayerCharacter::GASInputReleased ( FGameplayTag  InputTag )

protected

{
    FGameplayAbilitySpec* Spec = FindAbilitySpecByInputTag(InputTag);
 
    if (Spec == nullptr)
    {
        return;
    }
 
    Spec->InputPressed = false;
 
    if (Spec->IsActive())
    {
        ASC->AbilitySpecInputReleased(*Spec);
    }
}

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

GetCameraDistanceComponent()

UCameraZoomComponent * AMainPlayerCharacter::GetCameraDistanceComponent

(

)

const

{
    const APlayerController* PlayerController = Cast<APlayerController>(GetController());
 
    if (PlayerController == nullptr || PlayerController->PlayerCameraManager == nullptr)
    {
        return nullptr;
    }
 
    if (const AGameCameraManager* CameraManager = Cast<AGameCameraManager>(PlayerController->PlayerCameraManager))
    {
        return CameraManager->GetCameraZoomComponent();
    }
 
    return PlayerController->PlayerCameraManager->FindComponentByClass<UCameraZoomComponent>();
}

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

GetCharacterGhostWarpEffectComponent()

FORCEINLINE UCharacterGhostEffectComponent * AMainPlayerCharacter::GetCharacterGhostWarpEffectComponent ( ) const

inline

    {
        return CharacterGhostEffectComponent;
    }

GetChargeStateComponent()

UChargeStateComponent * AMainPlayerCharacter::GetChargeStateComponent ( ) const

overridevirtual

IChargeInterface를 구현.

{
    return ChargeStateComponent;
}

GetDefaultMappingContext()

FORCEINLINE UInputMappingContext * AMainPlayerCharacter::GetDefaultMappingContext ( ) const

inline

    {
        return PlayerExtendedData ? PlayerExtendedData->DefaultMappingContext : nullptr;
    }

GetDefaultWeaponTag()

FORCEINLINE FGameplayTag AMainPlayerCharacter::GetDefaultWeaponTag ( ) const

inline

    {
        return PlayerExtendedData->DefaultWeaponTag;
    }

GetHitReactMontage()

UAnimMontage * AMainPlayerCharacter::GetHitReactMontage ( ) const

overrideprotectedvirtual

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

{
    UWeaponLoadoutComponent* Loadout = GetWeaponLoadoutComponent();
    if (Loadout == nullptr)
    {
        return nullptr;
    }
 
    const UWeaponDefinition* Definition = Loadout->GetCurrentDefinition();
    if (Definition == nullptr)
    {
        return nullptr;
    }
    
    const bool bAttackIdle = ASC && ASC->HasMatchingGameplayTag(TAG_CHARACTER_STATE_COMBAT_ATTACKIDLE);
    return bAttackIdle ? Definition->HitReactMontage_AttackIdle : Definition->HitReactMontage_Idle;
}

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

GetMotionWarpingComponent()

FORCEINLINE UPlayerMotionWarpingComponent * AMainPlayerCharacter::GetMotionWarpingComponent ( ) const

inline

    {
        return MotionWarpingComponent;
    }

GetPlayerController()

FORCEINLINE APlayerController * AMainPlayerCharacter::GetPlayerController ( ) const

inline

    {
        return Controller ? Cast<APlayerController>(Controller) : nullptr;
    }

GetPlayerMovementComponent()

FORCEINLINE UPlayerMovementComponent * AMainPlayerCharacter::GetPlayerMovementComponent ( ) const

inline

    {
        return PlayerMovementComponent;
    }

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

GetPlayerTargetingComponent()

UCameraTargetingComponent * AMainPlayerCharacter::GetPlayerTargetingComponent

(

)

const

{
    const APlayerController* PlayerController = Cast<APlayerController>(GetController());
 
    if (PlayerController == nullptr || PlayerController->PlayerCameraManager == nullptr)
    {
        return nullptr;
    }
 
    if (const AGameCameraManager* CameraManager = Cast<AGameCameraManager>(PlayerController->PlayerCameraManager))
    {
        return CameraManager->GetPlayerTargetingComponent();
    }
 
    return PlayerController->PlayerCameraManager->FindComponentByClass<UCameraTargetingComponent>();
}

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

GetProjectileLauncherComponent()

FORCEINLINE UProjectileLauncherComponent * AMainPlayerCharacter::GetProjectileLauncherComponent ( ) const

inline

    {
        return ProjectileLauncherComponent;
    }

GetRawMovementInputDirection()

FORCEINLINE FVector AMainPlayerCharacter::GetRawMovementInputDirection ( ) const

inline

이동이 막혀 있어도 갱신되는 카메라 기준 이동 입력 방향. 최근 프레임 입력이 없으면 ZeroVector.

    {
        return GFrameCounter - RawMovementInputFrame <= 1 ? RawMovementInputDirection : FVector::ZeroVector;
    }

GetTargetingComponent()

FORCEINLINE UTargetingComponent * AMainPlayerCharacter::GetTargetingComponent ( ) const

inline

    {
        return TargetingComponent;
    }

GetWeaponLoadoutComponent()

FORCEINLINE UWeaponLoadoutComponent * AMainPlayerCharacter::GetWeaponLoadoutComponent ( ) const

inline

    {
        return WeaponLoadoutComponent;
    }

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

GetWeaponMeshComponent()

FORCEINLINE USkeletalMeshComponent * AMainPlayerCharacter::GetWeaponMeshComponent ( ) const

inline

    {
        return WeaponMesh;
    }

HasTargetingTarget()

bool AMainPlayerCharacter::HasTargetingTarget ( ETargetingMode  TargetingMode )

overridevirtual

IAttackableInterface를 구현.

{
    if (TargetingMode == ETargetingMode::SoftTargeting)
    {
        return TargetingComponent->GetSoftLockTarget() != nullptr;
    }
 
    if (TargetingMode == ETargetingMode::HardTargeting)
    {
        return TargetingComponent->GetHardLockTarget() != nullptr;
    }
    
    LOG_ERROR(LogCK, "지금 당장 김기백씨를 불러야된다니께유. ");
    return false;
}

InitializeAttributes()

void AMainPlayerCharacter::InitializeAttributes ( )

overrideprotectedvirtual

{
    AMainPlayerState* PS = GetPlayerState<AMainPlayerState>();
 
    if (!ASC || !CharacterControlData || !CharacterControlData->StatTable || !PS)
    {
        return;
    }
 
    UPlayerAttributeSet* PlayerAttributeSet = PS->GetPlayerAttributeSet();
 
    FPlayerStatTableRow* StatRow = CharacterControlData->StatTable->FindRow<FPlayerStatTableRow>(CharacterControlData->StatRowName, TEXT("PlayerStatContext"));
    if (!StatRow)
    {
        return;
    }
 
    if (!PlayerAttributeSet)
    {
        return;
    }
 
    // Base 공통 스탯 초기화
    PlayerAttributeSet->InitBaseStats
    (
        StatRow->Character_Hp,
        StatRow->Character_Move_Speed,
        StatRow->Character_Attack,
        StatRow->Character_Attack_Speed,
        StatRow->Character_Knockback_Resistance
    );
 
    // MoveSpeed 어트리뷰트를 실제 이동 속도로 반영 (이후 변경은 PostGameplayEffectExecute가 동기화)
    GetCharacterMovement()->MaxWalkSpeed = PlayerAttributeSet->GetMoveSpeed();
 
    // Player 전용 스탯 초기화
    PlayerAttributeSet->InitPlayerStats
    (
        StatRow->Character_Critical,
        StatRow->Character_Critical_Dmg
    );
}

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

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

InitializePlayerControllerDependencies()

void AMainPlayerCharacter::InitializePlayerControllerDependencies ( APlayerController *  PlayerController )

protected

{
    if (bPlayerControllerDependenciesInitialized)
    {
        return;
    }
 
    if (PlayerController == nullptr || CharacterControlData == nullptr || PlayerExtendedData == nullptr || PlayerExtendedData->DefaultMappingContext == nullptr)
    {
        return;
    }
 
    ULocalPlayer* LocalPlayer = PlayerController->GetLocalPlayer();
 
    if (LocalPlayer == nullptr)
    {
        return;
    }
 
    if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(LocalPlayer))
    {
        Subsystem->AddMappingContext(PlayerExtendedData->DefaultMappingContext, 0);
    }
 
    if (UCameraTargetingComponent* TargetingComp = GetPlayerTargetingComponent())
    {
        TargetingComp->OnTargetingActiveChanged.AddUObject(this, &ThisClass::OnTargetingChanged);
    }
 
    bPlayerControllerDependenciesInitialized = true;
}

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

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

Move()

void AMainPlayerCharacter::Move ( const FInputActionValue &  Value )

protected

{
    FVector2D MovementVector = Value.Get<FVector2D>();
 
    float InputSizeSquared = MovementVector.SquaredLength();
    float MovementVectorSize;
 
    if (InputSizeSquared > 1.0f)
    {
        MovementVector.Normalize();
        MovementVectorSize = 1.0f;
    }
    else
    {
        MovementVectorSize = FMath::Sqrt(InputSizeSquared);
    }
 
    AMainPlayerController* PlayerController = Cast<AMainPlayerController>(Controller);
    check(PlayerController);
 
    AGameCameraManager* CameraManager = Cast<AGameCameraManager>(PlayerController->PlayerCameraManager);
    check(CameraManager);
 
    const FRotator MovementInputRotation = CameraManager->GetMovementInputRotation();
    const FRotationMatrix RotationMatrix = FRotationMatrix(MovementInputRotation);
    const FVector ForwardDirection = RotationMatrix.GetUnitAxis(EAxis::X);
    const FVector RightDirection = RotationMatrix.GetUnitAxis(EAxis::Y);
 
    // 이동이 막혀 있어도 워프 조향 등에서 쓸 수 있도록 입력 방향은 항상 기록한다.
    RawMovementInputDirection = (ForwardDirection * MovementVector.Y + RightDirection * MovementVector.X).GetSafeNormal();
    RawMovementInputFrame = GFrameCounter;
 
    if (CanMove() == false)
    {
        return;
    }
 
    if (MovementVectorSize > 0.0f)
    {
        PlayerMovementComponent->UpdateMovementInputRotation(MovementInputRotation);
    }
 
    // 최종 이동 적용
    AddMovementInput(ForwardDirection, MovementVector.Y * MovementVectorSize);
    AddMovementInput(RightDirection, MovementVector.X * MovementVectorSize);
}

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

OnAnyGameplayEffectApplied()

void AMainPlayerCharacter::OnAnyGameplayEffectApplied ( UAbilitySystemComponent *  SourceASC, const FGameplayEffectSpec &  Spec, FActiveGameplayEffectHandle    )

protected

{
    // 죽거나 경면이면 실행 X 
    if (ASC == nullptr || IsDead() || IsStaggerImmune())
    {
        return;
    }
 
    FGameplayTagContainer AssetTags;
    Spec.GetAllAssetTags(AssetTags);
 
    const bool bIsKnockDownEffect = AssetTags.HasTag(TAG_EVENT_PLAYER_KNOCKDOWN);
    const bool bIsHitStunEffect = Spec.Def && Spec.Def->GetGrantedTags().HasTag(TAG_CHARACTER_STATE_ISHITSTUN);
 
    if (bIsKnockDownEffect == false && bIsHitStunEffect == false)
    {
        return;
    }
 
    // 강 경직 GE 
    if (bIsKnockDownEffect)
    {
        TriggerKnockDown(SourceASC, Spec);
        return;
    }
    
    // 강 경직 중인 경우 pass 
    if (ASC->HasMatchingGameplayTag(TAG_CHARACTER_STATE_ISKNOCKEDDOWN))
    {
        return;
    }
    
    // 약 경직 처리 
    
    // HitToKnockDownThreshold 이상일 경우 강 경직 실행 
    if (RecordHitStun())
    {
        TriggerKnockDown(SourceASC, Spec);
        return;
    }
 
    ASC->CancelAllAbilities();
 
    if (UCharacterMovementComponent* MovementComponent = GetCharacterMovement())
    {
        MovementComponent->StopMovementImmediately();
    }
 
    AActor* SourceActor = Spec.GetContext().GetEffectCauser();
    if (IsValid(SourceActor) == false && IsValid(SourceASC))
    {
        SourceActor = SourceASC->GetAvatarActor();
    }
 
    PlayHitReaction(SourceActor);
}

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

OnChargeBegin()

void AMainPlayerCharacter::OnChargeBegin ( )

overridevirtual

IChargeInterface를 구현.

{
    bIsCharging = true;
    ChangeAimState();
 
    if (ASC)
    {
        ASC->AddLooseGameplayTag(TAG_CHARACTER_STATE_ISBLOCKMOVEMENT);
    }
 
    if (UCharacterMovementComponent* MovementComp = GetCharacterMovement())
    {
        MovementComp->StopMovementImmediately();
    }
 
    BeginChargeFacingTurn();
}

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

OnChargeEnd()

void AMainPlayerCharacter::OnChargeEnd ( )

overridevirtual

IChargeInterface를 구현.

{
    bIsCharging = false;
    LookSensitivity = 1.0f;
    ChangeAimState();
 
    if (UWorld* World = GetWorld())
    {
        World->GetTimerManager().ClearTimer(ChargeFacingTurnTimerHandle);
    }
 
    // 차지 종료 — 기본 이동 방향 회전으로 복귀
    if (UCharacterMovementComponent* MovementComp = GetCharacterMovement())
    {
        MovementComp->bOrientRotationToMovement = true;
        MovementComp->bUseControllerDesiredRotation = false;
    }
 
    if (ASC)
    {
        ASC->RemoveLooseGameplayTag(TAG_CHARACTER_STATE_ISBLOCKMOVEMENT);
    }
}

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

OnChargePhaseChanged()

void AMainPlayerCharacter::OnChargePhaseChanged ( float  RotSpeedMul )

overridevirtual

IChargeInterface를 구현.

{
    LookSensitivity = RotSpeedMul;
}

OnDamageTaken()

void AMainPlayerCharacter::OnDamageTaken ( const FDamageResultData &  DamageResult )

overrideprotectedvirtual

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

{
    if (DamageResult.TargetActor != this || IsDead())
    {
        return;
    }
 
    ApplyDamageTakenEffect();
}

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

OnDeath()

void AMainPlayerCharacter::OnDeath ( )

protectedvirtual

{
    SetDead();
 
    const APlayerController* PlayerController = Cast<APlayerController>(GetController());
 
    if (PlayerController == nullptr || PlayerController->GetLocalPlayer() == nullptr)
    {
        LOG_ERROR(LogCKPlayer, "%s를 가져올 수 없습니다. ", NAMEOF(APlayerController));
        return;
    }
 
    UPlayerManagementSubsystem* PlayerManagement = PlayerController->GetLocalPlayer()->GetSubsystem<UPlayerManagementSubsystem>();
 
    if (PlayerManagement == nullptr)
    {
        LOG_ERROR(LogCKPlayer, "%s를 가져올 수 없습니다. ", NAMEOF(UPlayerManagementSubsystem));
        return;
    }
 
    PlayerManagement->HandlePlayerDeath(this);
}

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

OnHitStunTagChanged()

void AMainPlayerCharacter::OnHitStunTagChanged ( const FGameplayTag  CallbackTag, int32  NewCount  )

protected

{
    UPlayerMovementComponent* RotationComponent = GetPlayerMovementComponent();
 
    if (RotationComponent == nullptr)
    {
        return;
    }
    
    if (NewCount > 0)
    {
        RotationComponent->BeginManualRotation();
    }
    else
    {
        RotationComponent->EndManualRotation();
    }
}

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

OnMouseWheel()

void AMainPlayerCharacter::OnMouseWheel ( const FInputActionValue &  Value )

protected

{
    const float WheelValue = Value.Get<float>();
 
    UCameraTargetingComponent* CamTargetingComponent = GetPlayerTargetingComponent();
 
    if (CamTargetingComponent && CamTargetingComponent->HasTarget())
    {
        CamTargetingComponent->CycleTarget(WheelValue);
    }
    else if (UCameraZoomComponent* DistanceComponent = GetCameraDistanceComponent())
    {
        DistanceComponent->AdjustDistance(WheelValue);
    }
    else
    {
        LOG_WARNING(LogCK, "흑흑 나는 아무것도 조종할 수 없어.. ㅋㅋㅋㅋㅋㅋㅋ");
    }
}

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

OnMoveStarted()

void AMainPlayerCharacter::OnMoveStarted ( const FInputActionValue &  Value )

protected

{
    if (CanMove() == false)
    {
        return;
    }
 
    FGameplayEventData Payload;
    UAbilitySystemBlueprintLibrary::SendGameplayEventToActor(this, TAG_EVENT_INPUT_MOVE, Payload);
}

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

OnTargetingChanged()

void AMainPlayerCharacter::OnTargetingChanged ( bool  bActive )

protected

{
    bIsLockedOn = bActive;
    ChangeAimState();
}

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

PossessedBy()

void AMainPlayerCharacter::PossessedBy ( AController *  NewController )

overrideprotectedvirtual

{
    Super::PossessedBy(NewController);
 
    AMainPlayerState* GASPS = GetPlayerState<AMainPlayerState>();
 
    if (GASPS == nullptr)
    {
        return;
    }
 
    ASC = GASPS->GetAbilitySystemComponent();
    ASC->InitAbilityActorInfo(GASPS, this);
    ASC->GetGameplayAttributeValueChangeDelegate(UBaseAttributeSet::GetMoveSpeedAttribute()).AddUObject(this, &ThisClass::OnMoveSpeedChanged);
 
    InitializeAttributes();
 
    for (const auto& StartAbility : CharacterControlData->StartAbilities)
    {
        FGameplayAbilitySpec StartSpec(StartAbility, 1, INDEX_NONE, this);
        ASC->GiveAbility(StartSpec);
    }
 
    checkf(PlayerExtendedData, TEXT("%s가 nullptr입니다. "), NAMEOF_VAR(PlayerExtendedData));
 
    for (const auto& StartInputAbility : PlayerExtendedData->StartInputAbilities)
    {
        const FGameplayTag& InputTag = StartInputAbility.Key;
 
        if (!ensureAlwaysMsgf(InputTag.IsValid(), TEXT("StartInputAbilities 잘못된 엔트리. 스킵.")))
        {
            continue;
        }
 
        FGameplayAbilitySpec StartSpec(StartInputAbility.Value, 1, INDEX_NONE, this);
        StartSpec.GetDynamicSpecSourceTags().AddTag(InputTag);
        ASC->GiveAbility(StartSpec);
    }
 
    if (const UPlayerAttributeSet* CurrentAttributeSet = ASC->GetSet<UPlayerAttributeSet>())
    {
        CurrentAttributeSet->OnDeathDelegate.AddDynamic(this, &ThisClass::OnDeath);
        CurrentAttributeSet->OnDamageDelegate.AddUObject(this, &ThisClass::OnDamageTaken);
    }
 
    HitStunTagDelegateHandle = ASC->RegisterGameplayTagEvent(TAG_CHARACTER_STATE_ISHITSTUN, EGameplayTagEventType::NewOrRemoved).AddUObject(this, &ThisClass::OnHitStunTagChanged);
    if (GEAppliedDelegateHandle.IsValid() == false)
    {
        GEAppliedDelegateHandle = ASC->OnGameplayEffectAppliedDelegateToSelf.AddUObject(this, &ThisClass::OnAnyGameplayEffectApplied);
    }
 
    InitializePlayerControllerDependencies(Cast<APlayerController>(NewController));
 
    OnAbilitySystemReady.Broadcast(ASC);
}

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

PostInitializeComponents()

void AMainPlayerCharacter::PostInitializeComponents ( )

overrideprotectedvirtual

{
    Super::PostInitializeComponents();
 
    if (CharacterControlData)
    {
        PlayerExtendedData = CharacterControlData->FindExtendedData<FPlayerExtendedData>();
    }
    else
    {
        LOG_WARNING(LogCK, "%s가 없습니다. 의도한 사항이 맞습니까?", NAMEOF(UCharacterControlData));
    }
}

RecordHitStun()

bool AMainPlayerCharacter::RecordHitStun ( )

protected

{
    if (PlayerExtendedData == nullptr)
    {
        return false;
    }
 
    const float KnockDownWindow = PlayerExtendedData->HitToKnockDownWindow;
    const int32 KnockDownThreshold = PlayerExtendedData->HitToKnockDownThreshold;
 
    if (KnockDownWindow <= KINDA_SMALL_NUMBER)
    {
        return false;
    }
 
    const double CurrentTime = GetWorld()->GetTimeSeconds();
    RecentHitStunTimes.RemoveAll([CurrentTime, KnockDownWindow](const double HitTime)
    {
        return CurrentTime - HitTime > KnockDownWindow;
    });
 
    RecentHitStunTimes.Add(CurrentTime);
 
    if (RecentHitStunTimes.Num() < KnockDownThreshold)
    {
        return false;
    }
 
    return true;
}

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

ResetHitStunTimes()

void AMainPlayerCharacter::ResetHitStunTimes ( )

protected

{
    RecentHitStunTimes.Reset();
}

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

RespawnAtTransform()

void AMainPlayerCharacter::RespawnAtTransform

(

const FTransform &

RespawnTransform

)

{
    ResetHitStunTimes();
 
    if (UCameraTargetingComponent* CamTargetingComponent = GetPlayerTargetingComponent())
    {
        CamTargetingComponent->ReleaseTargeting();
    }
 
    bIsCharging = false;
    bIsLockedOn = false;
    LookSensitivity = 1.0f;
 
    if (UWorld* World = GetWorld())
    {
        World->GetTimerManager().ClearTimer(ChargeFacingTurnTimerHandle);
    }
 
    if (ASC)
    {
        ASC->CancelAllAbilities();
        ASC->RemoveAllGameplayCues();
        ASC->SetLooseGameplayTagCount(TAG_CHARACTER_STATE_ISDEAD, 0);
    }
 
    if (UCapsuleComponent* CapsuleComp = GetCapsuleComponent())
    {
        CapsuleComp->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
        CapsuleComp->SetCollisionProfileName(CPROFILE_CKPLAYERCAPSULE);
    }
 
    SetActorLocationAndRotation(RespawnTransform.GetLocation(), RespawnTransform.Rotator(), false, nullptr, ETeleportType::TeleportPhysics);
 
    if (UCharacterMovementComponent* MovementComp = GetCharacterMovement())
    {
        MovementComp->StopMovementImmediately();
        MovementComp->SetMovementMode(MOVE_Walking);
        MovementComp->bOrientRotationToMovement = true;
        MovementComp->bUseControllerDesiredRotation = false;
    }
 
    InitializeAttributes();
 
    if (APlayerController* PlayerController = Cast<APlayerController>(GetController()))
    {
        EnableInput(PlayerController);
    }
    else
    {
        LOG_ERROR(LogCK, "%s로 형변환할 수 없습니다. ", NAMEOF(APlayerController));
    }
}

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

RotateCamera()

void AMainPlayerCharacter::RotateCamera ( const FInputActionValue &  Value )

protected

{
    // 카메라 회전은 입력 차단 상태(IsBlockInput)에서만 막는다.
    // 차지 중에는 이동(IsBlockMovement)만 막고 카메라는 계속 조작 가능 — 캐릭터가 카메라 정면을 따라 회전한다.
    if (ASC && ASC->HasMatchingGameplayTag(TAG_CHARACTER_STATE_ISBLOCKINPUT))
    {
        return;
    }
 
    // 락온 중에는 마우스 회전을 무시 (LookOn 컴포넌트가 컨트롤러 회전을 직접 보간)
    const UCameraTargetingComponent* CamTargetingComponent = GetPlayerTargetingComponent();
 
    if (CamTargetingComponent && CamTargetingComponent->IsTargeting())
    {
        return;
    }
 
    FVector2D ScaledValue = Value.Get<FVector2D>() * LookSensitivity;
 
    const FGlobalUserSettingsRuntime SettingsRuntime = GetGlobalUserSettingsRuntime();
    const float Y = SettingsRuntime.bInvertYAxis ? -ScaledValue.Y : ScaledValue.Y;
 
    this->AddControllerYawInput(ScaledValue.X * SettingsRuntime.MouseXSensitivity);
    this->AddControllerPitchInput(Y * SettingsRuntime.MouseYSensitivity);
}

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

SetDead()

void AMainPlayerCharacter::SetDead ( )

overrideprotectedvirtual

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

{
    ResetHitStunTimes();
    Super::SetDead();
 
    if (APlayerController* PlayerController = Cast<APlayerController>(GetController()))
    {
        DisableInput(PlayerController);
    }
    else
    {
        LOG_ERROR(LogCK, "%s로 형변환할 수 없습니다. ", NAMEOF(APlayerController));
    }
}

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

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

SetupPlayerInputComponent()

void AMainPlayerCharacter::SetupPlayerInputComponent ( UInputComponent *  PlayerInputComponent )

overrideprotectedvirtual

{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
 
    if (!PlayerExtendedData)
    {
        return;
    }
 
    UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent);
 
    EnhancedInputComponent->BindAction(PlayerExtendedData->MoveAction, ETriggerEvent::Triggered, this, &ThisClass::Move);
    EnhancedInputComponent->BindAction(PlayerExtendedData->MoveAction, ETriggerEvent::Started, this, &ThisClass::OnMoveStarted);
    EnhancedInputComponent->BindAction(PlayerExtendedData->Cam_RotationAction, ETriggerEvent::Triggered, this, &ThisClass::RotateCamera);
    EnhancedInputComponent->BindAction(PlayerExtendedData->Cam_WheelAction, ETriggerEvent::Triggered, this, &ThisClass::OnMouseWheel);
    EnhancedInputComponent->BindAction(PlayerExtendedData->Cam_LockOnAction, ETriggerEvent::Started, this, &ThisClass::ToggleLockOn);
    EnhancedInputComponent->BindAction(PlayerExtendedData->DashAction, ETriggerEvent::Started, this, &ThisClass::GASInputPressed, TAG_INPUT_DASH.GetTag());
    EnhancedInputComponent->BindAction(PlayerExtendedData->AttackAction, ETriggerEvent::Triggered, this, &ThisClass::GASInputPressed, TAG_INPUT_ATTACK.GetTag());
    EnhancedInputComponent->BindAction(PlayerExtendedData->WarpStrikeAction, ETriggerEvent::Started, this, &ThisClass::GASInputPressed, TAG_INPUT_SKILL_STRIKE.GetTag());
    EnhancedInputComponent->BindAction(PlayerExtendedData->Weapon_SkillAction, ETriggerEvent::Started, this, &ThisClass::GASInputPressed, TAG_INPUT_SKILL_WEAPON.GetTag());
    EnhancedInputComponent->BindAction(PlayerExtendedData->Weapon_SkillAction, ETriggerEvent::Completed, this, &ThisClass::GASInputReleased, TAG_INPUT_SKILL_WEAPON.GetTag());
    EnhancedInputComponent->BindAction(PlayerExtendedData->WeaponRequestSkillAction, ETriggerEvent::Started, this, &ThisClass::GASInputPressed, TAG_INPUT_SKILL_WEAPONREQUEST.GetTag());
}

ToggleLockOn()

void AMainPlayerCharacter::ToggleLockOn ( )

protected

{
    if (UCameraTargetingComponent* CamTargetingComponent = GetPlayerTargetingComponent())
    {
        CamTargetingComponent->ToggleTargeting();
    }
    else
    {
        LOG_ERROR(LogCK, "%s를 가져올 수 없습니다. ", NAMEOF(UCameraTargetingComponent));
    }
}

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

TriggerKnockDown()

void AMainPlayerCharacter::TriggerKnockDown ( UAbilitySystemComponent *  SourceASC, const FGameplayEffectSpec &  Spec  )

protected

{
    ResetHitStunTimes();
 
    FGameplayEventData EventData;
    EventData.EventTag = TAG_EVENT_PLAYER_KNOCKDOWN;
    EventData.Instigator = Spec.GetContext().GetEffectCauser();
    if (IsValid(EventData.Instigator.Get()) == false && IsValid(SourceASC))
    {
        EventData.Instigator = SourceASC->GetAvatarActor();
    }
 
    EventData.Target = this;
    EventData.ContextHandle = Spec.GetContext();
    ASC->HandleGameplayEvent(TAG_EVENT_PLAYER_KNOCKDOWN, &EventData);
}

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

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

UpdateChargeFacingTurn()

void AMainPlayerCharacter::UpdateChargeFacingTurn ( )

protected

{
    const FRotator CurrentRotation(0.0f, GetActorRotation().Yaw, 0.0f);
    const FRotator TargetRotation(0.0f, ChargeFacingTargetYaw, 0.0f);
    const FRotator NewRotation = FMath::RInterpConstantTo(CurrentRotation, TargetRotation, 0.01f, 700.f);
 
    SetActorRotation(NewRotation);
 
    if (!NewRotation.Equals(TargetRotation, ChargeFacingTurnTolerance))
    {
        return;
    }
 
    if (UWorld* World = GetWorld())
    {
        World->GetTimerManager().ClearTimer(ChargeFacingTurnTimerHandle);
    }
}

멤버 데이터 문서화

bIsCharging

bool AMainPlayerCharacter::bIsCharging = false

private

bIsLockedOn

bool AMainPlayerCharacter::bIsLockedOn = false

private

bPlayerControllerDependenciesInitialized

bool AMainPlayerCharacter::bPlayerControllerDependenciesInitialized = false

protected

CharacterControlData

TObjectPtr<UCharacterControlData> AMainPlayerCharacter::CharacterControlData

protected

CharacterGhostEffectComponent

TObjectPtr<UCharacterGhostEffectComponent> AMainPlayerCharacter::CharacterGhostEffectComponent

protected

ChargeFacingTargetYaw

float AMainPlayerCharacter::ChargeFacingTargetYaw = 0.0f

private

ChargeFacingTurnTimerHandle

FTimerHandle AMainPlayerCharacter::ChargeFacingTurnTimerHandle

private

ChargeFacingTurnTolerance

float AMainPlayerCharacter::ChargeFacingTurnTolerance = 1.0f

private

ChargeStateComponent

TObjectPtr<UChargeStateComponent> AMainPlayerCharacter::ChargeStateComponent

protected

GEAppliedDelegateHandle

FDelegateHandle AMainPlayerCharacter::GEAppliedDelegateHandle

private

HitStunTagDelegateHandle

FDelegateHandle AMainPlayerCharacter::HitStunTagDelegateHandle

private

LookSensitivity

float AMainPlayerCharacter::LookSensitivity = 1.0f

private

MotionWarpingComponent

TObjectPtr<UPlayerMotionWarpingComponent> AMainPlayerCharacter::MotionWarpingComponent

protected

PlayerExtendedData

const FPlayerExtendedData* AMainPlayerCharacter::PlayerExtendedData = nullptr

PlayerMovementComponent

TObjectPtr<UPlayerMovementComponent> AMainPlayerCharacter::PlayerMovementComponent

protected

ProjectileLauncherComponent

TObjectPtr<UProjectileLauncherComponent> AMainPlayerCharacter::ProjectileLauncherComponent

protected

RawMovementInputDirection

FVector AMainPlayerCharacter::RawMovementInputDirection = FVector::ZeroVector

private

RawMovementInputFrame

uint64 AMainPlayerCharacter::RawMovementInputFrame = 0

private

RecentHitStunTimes

TArray<double> AMainPlayerCharacter::RecentHitStunTimes

private

TargetingComponent

TObjectPtr<UTargetingComponent> AMainPlayerCharacter::TargetingComponent

protected

WeaponLoadoutComponent

TObjectPtr<UWeaponLoadoutComponent> AMainPlayerCharacter::WeaponLoadoutComponent

protected

WeaponMesh

TObjectPtr<USkeletalMeshComponent> AMainPlayerCharacter::WeaponMesh

protected

---

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

• Source/CK_UE/Character/Player/MainPlayerCharacter.h
• Source/CK_UE/Character/Player/MainPlayerCharacter.cpp