Unreal Engine 5 배워보기 - 30일차

컴퓨터 및 게임 관련 전공인이 아닌 문외한 일반인이 언리얼 엔진을 배우면서 정리한 내용입니다.
그날그날 배웠던 내용을 제가 나중에 보기 위해 정리한 것으로, 지금 당장 보기에 부족한 점이 아주아주 많고 추후에 수정이 될 수도 있습니다.
오탈자 및 잘못 기재된 내용 지적, 부족한 내용 설명은 언제든지 환영입니다.

본글은 언리얼 엔진 5.5.4 버전 영문판을 기준으로 합니다.

----------------------------------------------------------------------------------------------------------------

 

 

30일차 학습 내용

- 문

 

 

문

문은 게임 내에서 구현하기 정말 어려운 기능 중 하나이다.

일단 문은 종류도 여러가지로 나뉜다.

플레이어가 열 수 있는 문이 있고, 플레이어가 열쇠가 있을 경우 열 수 있는 문, 아예 열 수 없는 문 등으로 나뉠 수도 있다.

문을 열려면 문과 플레이어 두 개체 간의 상호작용이 있어야 하고, 각 개체 별로 인식 및 출력해야할 것이 있다.

우선 문을 여는 플레이어는 문을 여는 상호작용 키를 누르는 여부가 있어야하고, 이 상호작용 키를 눌렀는 지의 여부를 바로 앞에 있는 문에게만 전달해줘야한다.

그리고 문은 바로 앞에 있는 개체가 플레이어인지, 현재 문 앞에 플레이어가 있을 경우 현재 상호작용이 가능한 상태인지 (그냥 열리는 문은 열리고, 열쇠가 필요한 문은 열쇠를 갖고 있는지 확인 후 열리게 해야함), 문이 열리는 방향이 앞인지 뒤인지 확인하고, 상호작용이 가능할 경우 애니메이션이 출력되도록, 소리가 출력되도록 해야한다.

현재 우리는 문이 열리고 닫히는 기능을 BP에서 작성했고 (29일차 내용 확인) 플레이어의 조작은 C++ 코드로 하고 있기에, 플레이어의 상호작용 키 입력 (C++) 이 문을 열리게 하도록 (BP) 전달해줄 방법을 생각해야한다.

C++ 코드에서 BP로 바로 접근하기 어렵고 오류가 날 가능성이 크기에, 직접적인 접근은 사실 상 안된다고 봐야한다.

이 경우 위 그림처럼 문을 관리할 부모 클래스를 C++로 생성하고, 캐릭터가 문을 관리하는 C++ 클래스에 상호작용 키 누를 것을 전달하여, 문을 관리하는 클래스에서 상호작용 키를 인식 시 문을 열어주는 BP를 호출한 뒤 실행만 시켜주면 된다.

일단은 문을 열리는 기능만 구현해보도록 하겠다.

문을 관리할 부모 클래스를 액터 형식으로 생성해주고, 해당 클래스의 이름을 "DoorManager" 라고 명명해준다.

그리고 아래와 같이 코드를 작성해준다.

DoorManager.h

public:
 
    void DoorOpen();
    
    UFUNCTION(BlueprintImplementableEvent)
    void DoorOpen_BP();

DoorManager.cpp

void ADoorManager::DoorOpen()
{
    DoorOpen_BP();
}

PlayerControl.cpp

void APlayerCharacterControl::Operate() // 아이템 습득 관리
{
    if (!isItem) // 반대 연산자
    {
        return;
    }
    
.
.
.
 
        if (name==TEXT("BP_Pistol")) // 이름 같은지 체크
        {
            IsWeaponMap[EWeaponType::Pistol] = true;
            //currentWeapon = EWeaponType::Pistol;
        }
        .
        .
        .
        else if (name == TEXT("BP_Plate")) // 문 인식
        {
            ADoorManager* doorManager = Cast<ADoorManager>(HitResult.GetActor());
            if (doorManager)
            {
                doorManager->DoorOpen();
            }
 
 
            return; // 함수를 끝내 아래 삭제 작업이 실행되지 않도록 함
        }
        
        
        FTimerHandle HitDelayHandle;
        GetWorld()->GetTimerManager().SetTimer(HitDelayHandle,
            FTimerDelegate::CreateLambda([HitResult]()
                {
                    HitResult.GetActor()->Destroy();
                }),
            0.5f,
            false
        );
.
.
.
}

아이템 습득을 담당하는 "Operate" 쪽으로 가서 문도 하나의 아이템으로 인식한 뒤, 문을 인식했을 경우 'DoorManager' 의 'DoorOpen' 함수를 실행하도록 해준 것이다.

그리고 아랫줄에 "return;' 을 추가하여, 문을 아이템으로 인식하고 상호작용 가능하게 하되 문이 사라지지 않도록 해주었다.

컴파일 후 문 BP로 들어가서 29일차에서 배치했던 충돌 관련 노드들을 싹 지워주고, "Class Settings" 를 누른 뒤 "Parent Class" 를 'DoorManager' 로 지정해준다.

그러면 위 그림과 같이 "DoorOpen_BP" 노드를 생성할 수 있고, Event Graph에 위 그림과 같이 BP를 작성해준다.

그러면 위 그림과 같이 문을 인식한 뒤 문이 사라지지 않고 열리는 것을 확인할 수 있다.

위에서 작성한 BP는 문을 열리게만 하는 것이기에 이번엔 열고 닫을 수 있도록 BP를 수정해주도록 하겠다.

열고 닫는 기능을 추가하면서 플레이어를 인식할 경우 열리도록 설정해보겠다.

우선 Line Trace를 이용하여 플레이어를 인식하도록 하고 싶기에, 문 앞쪽으로 Line Trace를 보내기 위한 "Scene" 을 추가하고 문 앞쪽으로 x축을 설정해주었다.

그리고 'isOpen' 이라는 변수로 문이 열려있는지의 여부를, ' isDoorFrontWorking' 과 'isDoorBackWorking' 이라는 변수로 문이 앞뒤로 열리는 상황을 각각 지정해주었다.

문이 열려있는지의 여부와 열려있는 방향을 지정해줌으로써 문을 조작할 시 열려있을 경우 닫히도록, 앞으로 열려있을 경우 뒤로 가도록 BP를 짜주었다.

위에서는 경우의 수를 6가지로 늘리기도 하였고 Timeline을 2개를 썼기에, 좀 더 간단하게 줄여보도록 하겠다.

위 그림과 같이 BP를 짜주면 간단하게 문을 어느 방향에서든지 열고 닫을 수 있다.

문이 열리면서 소리가 나도록 아래와 같이 코드를 추가해주도록 하겠다.

DoorManager.cpp

void ADoorManager::DoorOpen()
{
    DoorOpen_BP();
 
    float VolumeMultiplier = 1.0f; // 소리 볼륨 배율
    float PitchMultiplier = 1.0f; // 소리 피치 배율
    float StartTime = 0.0f; // 소리 재생 시작 시간
    USoundAttenuation* AttenuationSettings = nullptr; // 사운드 감쇠 설정
    USoundConcurrency* ConcurrencySettings = nullptr; // 사운드 동시성 설정
 
    UGameplayStatics::PlaySoundAtLocation (GetWorld(), DoorOpenSound, GetActorLocation(), VolumeMultiplier, PitchMultiplier, StartTime, AttenuationSettings, ConcurrencySettings);
}

이번 시간에는 소리를 나게 하는 것까지 하지는 않고 우선은 코드만 입력해주었기에, 위와 같이 작성 후 전부 주석처리 해주었다.

 

 

*오늘까지 작성한 코드 정리

PlayerControl.h ()

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "InputActionValue.h"
#include "Components/Image.h" // UImage 추가
#include "Components/TextBlock.h" // UTextblock 추가
#include "Blueprint/UserWidget.h"
#include "PlayerCharacterControl.generated.h"
 
UENUM() // 아이템 목록 Enum
enum class EWeaponType : uint8
{
    None UMETA(DisplayName = "None"),
    Pistol UMETA(DisplayName = "Pistol"),
    SMG UMETA(DisplayName = "SMG"),
    Rifle UMETA(DisplayName = "Rifle"),
    
};
 
 
 
UCLASS()
class MYPROJECT_API APlayerCharacterControl : public ACharacter
{
    GENERATED_BODY()
 
public:
    // Sets default values for this character's properties
    APlayerCharacterControl();
 
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;
 
public:    
    // Called every frame
    virtual void Tick(float DeltaTime) override;
 
    // Called to bind functionality to input
    virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
 
 
protected: // ======================================================================Camera
    UPROPERTY(EditAnywhere, BlueprintReadWrite) // readwrite 추가
    class USpringArmComponent* SpringArm;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite) // 총알 발사 수정
    class UCameraComponent* Camera;
 
private: // ======================================================================Input
    UPROPERTY(VisibleAnywhere, Category = "Input")
    class UInputMappingContext* DefaultContext;
 
    UPROPERTY(VisibleAnywhere, Category = "Input")
    class UInputAction* MoveAction;
 
    UPROPERTY(VisibleAnywhere, Category = "Input")
    class UInputAction* LookAction;
 
    UPROPERTY(VisibleAnywhere, Category = "Input")
    class UInputAction* AimAction;
 
    UPROPERTY(VisibleAnywhere, Category = "Input")
    class UInputAction* FireAction;
 
    UPROPERTY(VisibleAnywhere, Category = "Input")
    class UInputAction* OperateAction;
    
    UPROPERTY(VisibleAnywhere, Category = "Input")
    class UInputAction* RifleChangeAction;
 
    UPROPERTY(VisibleAnywhere, Category = "Input")
    class UInputAction* PistolChangeAction;
    
    UPROPERTY(VisibleAnywhere, Category = "Input")
    float mousespeed = 30.0f;
 
public:
    UFUNCTION(BlueprintImplementableEvent, Category = "Input")
    void OnFire_BP(); // 정의 없이 선언만 있음; public으로 해야함! 중요!
 
    UFUNCTION(BlueprintImplementableEvent, Category = "Input") // 줌인 시 크로스헤어 추가 생성
    void OnAim_BP();
 
    UFUNCTION(BlueprintImplementableEvent, Category = "Input") // 줌아웃 시 크로스헤어 추가를 위해 생성
    void OffAim_BP();
 
    UFUNCTION(BlueprintImplementableEvent, Category = "Input")
    void Operate_BP();
 
public: // ======================================================================Function
    void Move(const FInputActionValue& value);
    void Look(const FInputActionValue& value);
    void OnAim();
    void OffAim();
    void Fire();
    void Operate();
    void RifleMode();
    void PistolMode();
 
    void InitFindWidget();
    void InitFindWeaponMesh();
    void InitIsWeaponMap();
    void InitFindInput();
    
public: // ======================================================================Anim
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* RifleAimMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* PistolAimMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* RifleFireMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* PistolFireMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* OperateMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* WeaponChangeInMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Animation")
    UAnimMontage* WeaponChangeOutMontage;
 
public: // ======================================================================Sound
    UPROPERTY(EditAnywhere, Category = "Sound")
    USoundBase* RifleSound;
 
    UPROPERTY(EditAnywhere, Category = "Sound")
    USoundBase* PistolSound;
 
    UPROPERTY(EditAnywhere, Category = "Sound")
    USoundBase* SMGSound;
 
    UPROPERTY(EditAnywhere, Category = "Sound")
    USoundBase* HitSound;
 
    UPROPERTY(EditAnywhere, Category = "Sound")
    USoundBase* WeaponChangeSound; // 새로 추가
 
    void WeaponFireSound(); // 변수가 아니라 UPROPERTY 추가해주면 안됨
 
private: // ======================================================================Weapon
    UPROPERTY(EditAnywhere)
    class UStaticMeshComponent* SM_RifleWeapon;
 
    UPROPERTY(EditAnywhere)
    class UStaticMeshComponent* SM_PistolWeapon;
 
    UPROPERTY(EditAnywhere)
    class UStaticMeshComponent* SM_SMGWeapon;
 
public:    
    UPROPERTY(EditAnywhere, BlueprintReadOnly) // 초기 상태를 아무것도 들고 있지 않은 상태로 함
    EWeaponType currentWeapon = EWeaponType::None;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite) // 아이템 목록 map 추가
    TMap<EWeaponType, bool> IsWeaponMap;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    int RifleBulletCount = 30;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    int PistolBulletCount = 8;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    int SMGBulletCount = 60;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly) // 장전된 총알
    int CurrentBulletCount = 0;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly) // 소유 중인 총알
    int SaveBulletCount = 0;
 
public: // ======================================================================PlayerState
    UPROPERTY(EditAnywhere, BlueprintReadWrite) 
    bool isItem = false; // 아이템 확인 변수 추가
    bool isAim = false;
 
public: // ======================================================================CameraShake
    UPROPERTY(EditAnywhere)
    TSubclassOf<class UCameraShakeBase> RifleFireCameraShakeClass;
 
    UPROPERTY(EditAnywhere)
    TSubclassOf<class UCameraShakeBase> PistolFireCameraShakeClass;
 
    UPROPERTY(EditAnywhere)
    TSubclassOf<class UCameraShakeBase> SMGFireCameraShakeClass;
 
public: // ======================================================================Widget
 
    UPROPERTY(EditAnywhere, Category = "Widget")
    TSubclassOf<class UUserWidget> HUDClass = nullptr;
 
    UPROPERTY()
    class UUserWidget* HUDWidget;
 
    UImage* CrossHairImage;
    UImage* WeaponIconImage;
    UTextBlock* BulletCountTextBlock;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    TMap<EWeaponType, UTexture2D*> WeaponCrosshairImageMap;
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    TMap<EWeaponType, UTexture2D*> WeaponIconImageMap;
};

PlayerControl.cpp

// Fill out your copyright notice in the Description page of Project Settings.
 
 
#include "PlayerCharacterControl.h"
#include "Components/SkeletalMeshComponent.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
#include "InputMappingContext.h"
#include "Components/StaticMeshComponent.h"
#include "PlayerAnimInstance.h"
#include "Kismet/GameplayStatics.h" // 새로 추가 사운드 추가할 때 소리 재생 시 필수
#include "Engine/DamageEvents.h" // 아이템 습득 시 추가
#include "Blueprint/UserWidget.h" // 위젯 추가
#include "Components/Image.h" // 위젯 내 이미지 불러오기 추가
#include "Internationalization/Text.h" // FText로 변환하기 위해 추가
#include "DoorManager.h" // 문 인식 추가
 
// Sets default values
APlayerCharacterControl::APlayerCharacterControl()
{
     // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
 
    ConstructorHelpers::FObjectFinder<USkeletalMesh>PlayerMesh(TEXT("/Script/Engine.SkeletalMesh'/Game/Asset/Player/Survival_Character/Meshes/SK_Survival_Character.SK_Survival_Character'"));
        
    if (PlayerMesh.Succeeded())
    {
        GetMesh()->SetSkeletalMesh(PlayerMesh.Object);  // 스켈레톤 보유
        GetMesh()->SetWorldLocationAndRotation(FVector(0, 0, -90), FRotator(0, -90, 0)); // 스켈레톤에 이동 및 회전 부여
    }
 
    SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));  // Spring Arm 생성 및 회전 및 각도를 조절하여 Root에 장착
    SpringArm->SetupAttachment(RootComponent);
    SpringArm->SetWorldLocation(FVector(45, 22, 55.0f));
    SpringArm->TargetArmLength = 200;
    SpringArm->SocketOffset = FVector(23, 30, 0);
    SpringArm->bUsePawnControlRotation = true;
 
    Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera")); // Camera 생성 및 Spring Arm에 장착
    Camera->SetupAttachment(SpringArm);
 
    static ConstructorHelpers::FClassFinder<UAnimInstance>AnimInstance(TEXT("/Game/Blueprint/ABP_Player.ABP_Player_C")); // Animation BP 지정; 클래스의 경우는 _C 추가, 경로 상에 '가 들어가있으면 안됨
 
    if (AnimInstance.Class)
    {
        GetMesh()->SetAnimInstanceClass(AnimInstance.Class);
    }
    
    InitFindWeaponMesh();
    InitFindInput();    
}
 
// Called when the game starts or when spawned
void APlayerCharacterControl::BeginPlay()
{
    Super::BeginPlay();
    
    InitFindWidget();
    InitIsWeaponMap();
 
    if (APlayerController* PlayerController = Cast<APlayerController>(GetController())) // PlayerController 관련
    {
        if(UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
        {
            Subsystem->AddMappingContext(DefaultContext, 0);
        }
    }
        
    //SM_Weapon->bHiddenInGame = true;
    //SM_Weapon->IsVisible();
    SM_RifleWeapon->SetVisibility(false);
    SM_PistolWeapon->SetVisibility(false);
 
    if (!HUDWidget && HUDClass) // 게임 실행 시 바로 위젯 생성
    {
        HUDWidget = CreateWidget(GetWorld()->GetFirstPlayerController(), HUDClass);
    }
    if (HUDWidget)
    {
        HUDWidget->AddToViewport();
 
        CrossHairImage = Cast<UImage>(HUDWidget->GetWidgetFromName(TEXT("CrosshairImage")));
        WeaponIconImage = Cast<UImage>(HUDWidget->GetWidgetFromName(TEXT("WeaponIconImage")));
        BulletCountTextBlock = Cast<UTextBlock>(HUDWidget->GetWidgetFromName(TEXT("BulletText")));
        if (CrossHairImage)
        {
            CrossHairImage->SetVisibility(ESlateVisibility::Hidden);
        }
        if (WeaponIconImage)
        {
            WeaponIconImage->SetVisibility(ESlateVisibility::Hidden);
        }
        if (BulletCountTextBlock)
        {
            BulletCountTextBlock->SetVisibility(ESlateVisibility::Hidden);
        }
    }
}
 
// Called every frame
void APlayerCharacterControl::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
}
 
// Called to bind functionality to input
void APlayerCharacterControl::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) // IMC 관련
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);
    EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &APlayerCharacterControl::Move);
    EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &APlayerCharacterControl::Look);
    EnhancedInputComponent->BindAction(AimAction, ETriggerEvent::Started, this, &APlayerCharacterControl::OnAim); // 조준 관련
    EnhancedInputComponent->BindAction(AimAction, ETriggerEvent::Completed, this, &APlayerCharacterControl::OffAim);
    EnhancedInputComponent->BindAction(FireAction, ETriggerEvent::Started, this, &APlayerCharacterControl::Fire); // 사격 관련
    EnhancedInputComponent->BindAction(OperateAction, ETriggerEvent::Started, this, &APlayerCharacterControl::Operate); // 아이템 감지 관련
    EnhancedInputComponent->BindAction(RifleChangeAction, ETriggerEvent::Started, this, &APlayerCharacterControl::RifleMode);
    EnhancedInputComponent->BindAction(PistolChangeAction, ETriggerEvent::Started, this, &APlayerCharacterControl::PistolMode);
}
 
void APlayerCharacterControl::Move(const FInputActionValue& value) // IA_Move 관련 값 계산
{
    const FVector2D MovementVector = value.Get<FVector2D>();
    const FRotator Rotation = Controller->GetControlRotation();
    const FRotator YawRotation(0, Rotation.Yaw, 0);
        
    const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
 
    AddMovementInput(ForwardDirection, MovementVector.Y);
    AddMovementInput(RightDirection, MovementVector.X);
}
 
void APlayerCharacterControl::Look(const FInputActionValue& value) // IA_Look 관련 값 계산
{
    FVector2D LookAxisVector = value.Get<FVector2D>();
 
    AddControllerYawInput(LookAxisVector.X * GetWorld()->DeltaTimeSeconds * mousespeed);
    AddControllerPitchInput(LookAxisVector.Y * GetWorld()->DeltaTimeSeconds * -mousespeed);
}
 
void APlayerCharacterControl::OnAim() // 조준 상태 애니메이션 연결
{
    if (IsWeaponMap.Num() > 0)
    {
        if (CrossHairImage)
        {
            CrossHairImage->SetVisibility(ESlateVisibility::Visible);
        }
        if (WeaponIconImage)
        {
            WeaponIconImage->SetVisibility(ESlateVisibility::Visible);
        }
        if (BulletCountTextBlock)
        {
            BulletCountTextBlock->SetVisibility(ESlateVisibility::Visible);
        }
                
        if (IsWeaponMap.Contains(EWeaponType::Rifle) && currentWeapon == EWeaponType::Rifle) // 라이플 소유 및 장비 여부 확인
        {
            OnAim_BP();
            UPlayerAnimInstance* animInstance = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance()); // 플레이어에게 값 조정으로 변화하는거 체크용
            isAim = true; // 조준 가능
            animInstance->isAim = true;
            CurrentBulletCount = RifleBulletCount; // 추가
            // 무기 상태를 AnimInstance 전달 필요
        }
        else if (IsWeaponMap.Contains(EWeaponType::Pistol) && currentWeapon == EWeaponType::Pistol) // 권총 소유 및 장비 여부 확인
        {
            OnAim_BP();
            UPlayerAnimInstance* animInstance = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance()); // 플레이어에게 값 조정으로 변화하는거 체크용
            isAim = true; // 조준 가능
            animInstance->isAim = true;
            CurrentBulletCount = PistolBulletCount;
        }
        else if (IsWeaponMap.Contains(EWeaponType::SMG) && currentWeapon == EWeaponType::SMG) // SMG 소유 및 장비 여부 확인
        {
            OnAim_BP();
            UPlayerAnimInstance* animInstance = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance()); // 플레이어에게 값 조정으로 변화하는거 체크용
            isAim = true; // 조준 가능
            animInstance->isAim = true;
            CurrentBulletCount = SMGBulletCount;
        }
 
        FText currentBullet = FText::AsNumber(CurrentBulletCount); // AsNumber를 사용하여 int32 -> FText 변환
        FText saveBullet = FText::AsNumber(SaveBulletCount);
        FText text = FText::Format(FText::FromString(TEXT("{0}/{1}")), currentBullet, saveBullet); // BP에서 사용했던 Format Text와 유사한 방식
 
        BulletCountTextBlock->SetText(text); // BulletCountTextBlock에 현재 총알 / 소유 중 총알 표시
    }
 
}
 
void APlayerCharacterControl::OffAim() // 비조준 상태 애니메이션 연결
{
    if (CrossHairImage)
    {
        CrossHairImage->SetVisibility(ESlateVisibility::Hidden);
    }
    if (WeaponIconImage)
    {
        WeaponIconImage->SetVisibility(ESlateVisibility::Hidden);
    }
    if (BulletCountTextBlock)
    {
        BulletCountTextBlock->SetVisibility(ESlateVisibility::Hidden);
    }
    OffAim_BP();
    UPlayerAnimInstance* animInstance = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
    isAim = false; // 조준 불가능
    animInstance->isAim = false;
}
 
void APlayerCharacterControl::Fire() // 사격 상태 애니메이션 연결
{
    if (isAim)
    {
        if (currentWeapon == EWeaponType::Rifle && RifleBulletCount > 0) // Camera Shake 장탄 수 0일 경우 출력 X
        {
            CurrentBulletCount--;
            RifleBulletCount = CurrentBulletCount; // 줄어든 탄창 수를 저장
                        
            if (RifleFireCameraShakeClass)
            {
                GetWorld()->GetFirstPlayerController()->ClientStartCameraShake(RifleFireCameraShakeClass);
            }
        }
 
        else if (currentWeapon == EWeaponType::Pistol && PistolBulletCount > 0)
        {
            CurrentBulletCount--;
            PistolBulletCount = CurrentBulletCount;
            
            if (PistolFireCameraShakeClass)
            {
                GetWorld()->GetFirstPlayerController()->ClientStartCameraShake(PistolFireCameraShakeClass);
            }
        }
 
        else if (currentWeapon == EWeaponType::SMG && SMGBulletCount > 0)
        {
            CurrentBulletCount--;
            SMGBulletCount = CurrentBulletCount;
            
            if (SMGFireCameraShakeClass)
            {
                GetWorld()->GetFirstPlayerController()->ClientStartCameraShake(SMGFireCameraShakeClass);
            }
        }
 
        OnFire_BP();
        FHitResult Hit;
        FVector StartTrace = Camera->GetComponentLocation();
        FVector EndTrace = StartTrace + (Camera->GetForwardVector() * 1000);
        DrawDebugLine(GetWorld(), StartTrace, EndTrace, FColor::Green, false, 5.0f);
        if (GetWorld()->LineTraceSingleByChannel(Hit, StartTrace, EndTrace, ECC_GameTraceChannel6))
        {
            Hit.GetActor()->Destroy();
        }
 
        //OnFire_BP(); // BP 동시실행 중요중요중요
        UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance();
        if (currentWeapon == EWeaponType::Rifle)
        {
            if (RifleFireMontage)
            {
                AnimInstance->Montage_Play(RifleFireMontage, 0.233333f);
            }
            FTimerHandle FireSoundDelayHandle; // 추가
            GetWorld()->GetTimerManager().SetTimer(FireSoundDelayHandle, this,
                &APlayerCharacterControl::WeaponFireSound,
                0.2f,
                false
            );
        }
        
        else if (currentWeapon == EWeaponType::Pistol)
        {
            if (PistolFireMontage)
            {
                AnimInstance->Montage_Play(PistolFireMontage);
            }
            FTimerHandle FireSoundDelayHandle; // 추가
            GetWorld()->GetTimerManager().SetTimer(FireSoundDelayHandle, this,
                &APlayerCharacterControl::WeaponFireSound,
                0.2f,
                false
            );
        }
    
    }
 
    FText currentBullet = FText::AsNumber(CurrentBulletCount); // Fire에서 소모한 
    FText saveBullet = FText::AsNumber(SaveBulletCount);
    FText text = FText::Format(FText::FromString(TEXT("{0}/{1}")), currentBullet, saveBullet);
 
    BulletCountTextBlock->SetText(text);
}
 
void APlayerCharacterControl::Operate() // 아이템 습득 관리
{
    if (!isItem) // 반대 연산자
    {
        return;
    }
    
    Operate_BP();
 
    FVector StartLocation = GetMesh()->GetSocketLocation("hand_r");
    FVector EndLocation = StartLocation;
    float SphereRadius = 70.0f;
    FHitResult HitResult;
    FCollisionQueryParams Params;
    Params.AddIgnoredActor(this); // 자기자신을 무시
    bool isHit = GetWorld()->SweepSingleByChannel(HitResult, StartLocation, EndLocation, FQuat::Identity, ECC_GameTraceChannel9, FCollisionShape::MakeSphere(SphereRadius), Params);
    /*DrawDebugSphere(GetWorld(), StartLocation, SphereRadius, 12, FColor::Red, false, 1.0f);*/
    if (isHit) // 습득한 아이템과 map의 아이템 일치 여부 확인
    {
        FString name = HitResult.GetActor()->GetName();
 
        name = name.LeftChop(1);
        name = name.LeftChop(name.Len()-name.Find(TEXT("_C_"))); 
        /*if (name.Find(TEXT("BP_")) == 0)
        {
            name = name.RightChop(3);
        }*/
        /*name = name.RightChop(name.Len()-name.Find(TEXT("BP_")));
        name = name.RightChop(3);*/
        /*
        * 만약, name에 BP_가 존재한다면,  -> if
        * 앞에서부터 3개를 잘라라  -> RightChop
        * 
        */
        GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, FString::Printf(TEXT("%s"), *name));
 
        if (name==TEXT("BP_Pistol")) // 이름 같은지 체크
        {
            IsWeaponMap[EWeaponType::Pistol] = true;
            //currentWeapon = EWeaponType::Pistol;
        }
        else if(name == TEXT("SMG"))
        {
            IsWeaponMap[EWeaponType::SMG] = true;
            //currentWeapon = EWeaponType::SMG;
        }
        else if (name == TEXT("Rifle"))
        {
            IsWeaponMap[EWeaponType::Rifle] = true;
            //currentWeapon = EWeaponType::Rifle;
        }
        
        else if (name == TEXT("BP_RifleBullet"))
        {
            RifleBulletCount += 30;
            if (RifleBulletCount >= 200)
            {
                RifleBulletCount = 200;
            }
        }
        else if (name == TEXT("BP_PistolBullet"))
        {
            PistolBulletCount += 8;
            if (RifleBulletCount >= 120)
            {
                RifleBulletCount = 120;
            }
        }
        else if (name == TEXT("BP_SMGBullet"))
        {
            SMGBulletCount += 30;
            if (SMGBulletCount >= 200)
            {
                SMGBulletCount = 200;
            }
        }
        else if (name == TEXT("BP_Plate")) // 문 인식
        {
            ADoorManager* doorManager = Cast<ADoorManager>(HitResult.GetActor());
            if (doorManager)
            {
                doorManager->DoorOpen();
            }
 
            return; // 함수를 끝내 아래 삭제 작업이 실행되지 않도록 함
        }
        
        
        FTimerHandle HitDelayHandle;
        GetWorld()->GetTimerManager().SetTimer(HitDelayHandle,
            FTimerDelegate::CreateLambda([HitResult]()
                {
                    HitResult.GetActor()->Destroy();
                }),
            0.5f,
            false
        );
 
        
    }
 
    /*UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance();
    if (OperateMontage)
    {
        AnimInstance->Montage_Play(OperateMontage, 1.0f);
    }*/
}
 
void APlayerCharacterControl::RifleMode() // 라이플 장비
{
    GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, TEXT("123"));
    if (IsWeaponMap.Num() > 0 && currentWeapon == EWeaponType::Pistol && IsWeaponMap.Contains(EWeaponType::Rifle))
    {
        if (WeaponChangeInMontage)
        {
            FVector2D currentImagesize = WeaponIconImage->Brush.ImageSize;
            
            if (WeaponIconImage && WeaponIconImageMap[EWeaponType::Rifle] && WeaponIconImageMap.Num() > 0 && WeaponIconImageMap.Contains(EWeaponType::Rifle))
            {
                WeaponIconImage->SetBrushFromTexture(WeaponIconImageMap[EWeaponType::Rifle]);
                WeaponIconImage->SetBrushSize(currentImagesize);
            }
 
 
            if (CrossHairImage && WeaponCrosshairImageMap[EWeaponType::Rifle] && WeaponCrosshairImageMap.Num() > 0 && WeaponCrosshairImageMap.Contains(EWeaponType::Rifle))
            {
                CrossHairImage->SetBrushFromTexture(WeaponCrosshairImageMap[EWeaponType::Rifle]);
                CrossHairImage->SetBrushSize(currentImagesize);
            }
            
            UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance();
            float InMontageDuration = AnimInstance->Montage_Play(WeaponChangeInMontage); // 애니메이션 순차 재생을 위해 무기 넣는 애니메이션 재생 후 무기 꺼내는 애니메이션 진행하도록 함
 
                FTimerHandle HideHandle;
                GetWorld()->GetTimerManager().SetTimer(HideHandle,
                    FTimerDelegate::CreateLambda([this]()
                        {
                            if (WeaponChangeSound)
                            {
                                UGameplayStatics::PlaySound2D(this, WeaponChangeSound);
                                //SM_Weapon->bHiddenInGame = false;
                                /*SM_Weapon->IsVisible(); */ // 상태여부
                                SM_PistolWeapon->SetVisibility(false);
                            }
                            if (WeaponChangeOutMontage)
                            {
                                UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance();
                                float OutMontageDuration = AnimInstance->Montage_Play(WeaponChangeOutMontage);
 
                                FTimerHandle ShowHandle;
                                GetWorld()->GetTimerManager().SetTimer(ShowHandle,
                                    FTimerDelegate::CreateLambda([this]()
                                        {
                                            if (WeaponChangeSound)
                                            {
                                                UGameplayStatics::PlaySound2D(this, WeaponChangeSound);
                                                SM_RifleWeapon->SetVisibility(true);
                                                UPlayerAnimInstance* playeranimInstance = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
                                                playeranimInstance->WeaponTypeCount = 1;
                                                currentWeapon = EWeaponType::Rifle;
                                            }
                                        }),
                                    OutMontageDuration,
                                    false
                                );
                            }
 
                        }),
                    InMontageDuration,
                    false
                );
        }
            else if (IsWeaponMap.Contains(EWeaponType::Rifle) && IsWeaponMap.Num() > 0 && IsWeaponMap[EWeaponType::Rifle] == true)
            {
                if (WeaponChangeOutMontage)
                {
                    FVector2D currentImagesize = WeaponIconImage->Brush.ImageSize;
 
                    if (WeaponIconImage && WeaponIconImageMap[EWeaponType::Rifle] && WeaponIconImageMap.Num() > 0 && WeaponIconImageMap.Contains(EWeaponType::Rifle))
                    {
                        WeaponIconImage->SetBrushFromTexture(WeaponIconImageMap[EWeaponType::Rifle]);
                        WeaponIconImage->SetBrushSize(currentImagesize);
                    }
                
                    if (CrossHairImage && WeaponCrosshairImageMap[EWeaponType::Rifle] && WeaponCrosshairImageMap.Num() > 0 && WeaponCrosshairImageMap.Contains(EWeaponType::Rifle))
                    {
                        CrossHairImage->SetBrushFromTexture(WeaponCrosshairImageMap[EWeaponType::Rifle]);
                        CrossHairImage->SetBrushSize(currentImagesize);
                    }
 
                    UAnimInstance* AnimInstace = GetMesh()->GetAnimInstance();
                    AnimInstace->Montage_Play(WeaponChangeOutMontage);
                }
                FTimerHandle HitDelayHandle;
                GetWorld()->GetTimerManager().SetTimer(HitDelayHandle,
                    FTimerDelegate::CreateLambda([this]()
                        {
                            if (WeaponChangeSound)
                            {
                                UGameplayStatics::PlaySound2D(this, WeaponChangeSound);
                                SM_RifleWeapon->SetVisibility(true);
                                UPlayerAnimInstance* playeranimInstance = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
                                playeranimInstance->WeaponTypeCount = 1;
                                currentWeapon = EWeaponType::Rifle;
                            }
                        }),
                    0.5f,
                    false
                );
            }
            else // 총이 없는 경우
            {
                UGameplayStatics::PlaySound2D(this, WeaponChangeSound);
            }    
    }
}
 
void APlayerCharacterControl::PistolMode() // 권총 장비
{
    if (IsWeaponMap.Num() > 0 && currentWeapon == EWeaponType::Rifle && IsWeaponMap.Contains(EWeaponType::Pistol))
    {
        if (WeaponChangeInMontage) // 무기 집어넣는 동작을 먼저 해야하기에 먼저 삽입
        {
            FVector2D currentImagesize = WeaponIconImage->Brush.ImageSize;
            
            if (WeaponIconImage && WeaponIconImageMap[EWeaponType::Pistol] && WeaponIconImageMap.Num() > 0 && WeaponIconImageMap.Contains(EWeaponType::Pistol))
            {
                WeaponIconImage->SetBrushFromTexture(WeaponIconImageMap[EWeaponType::Pistol]);
                WeaponIconImage->SetBrushSize(currentImagesize);
            }
            
            if (CrossHairImage && WeaponCrosshairImageMap[EWeaponType::Pistol] && WeaponCrosshairImageMap.Num() > 0 && WeaponCrosshairImageMap.Contains(EWeaponType::Pistol))
            {
                CrossHairImage->SetBrushFromTexture(WeaponCrosshairImageMap[EWeaponType::Pistol]);
                CrossHairImage->SetBrushSize(currentImagesize);
            }
            
            UAnimInstance* AnimInstace = GetMesh()->GetAnimInstance();
            float InMontageDuration = AnimInstace->Montage_Play(WeaponChangeInMontage);
 
            FTimerHandle HideHandle;
            GetWorld()->GetTimerManager().SetTimer(HideHandle,
                FTimerDelegate::CreateLambda([this]()
                    {
                        if (WeaponChangeSound)
                        {
                            UGameplayStatics::PlaySound2D(this, WeaponChangeSound);
                            SM_RifleWeapon->SetVisibility(false);
                        }
 
                        if (WeaponChangeOutMontage) // 무기 집어넣었으니 무기를 꺼내는 동작 삽입
                        {
                            UAnimInstance* AnimInstace = GetMesh()->GetAnimInstance();
                            float OutMontageDuration = AnimInstace->Montage_Play(WeaponChangeOutMontage);
 
                            FTimerHandle ShowHandle;
                            GetWorld()->GetTimerManager().SetTimer(ShowHandle,
                                FTimerDelegate::CreateLambda([this]()
                                    {
                                        if (WeaponChangeSound)
                                        {
                                            UGameplayStatics::PlaySound2D(this, WeaponChangeSound);
                                            SM_PistolWeapon->SetVisibility(true);
                                            UPlayerAnimInstance* playeranimInstance = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
                                            playeranimInstance->WeaponTypeCount = 2;
                                            currentWeapon = EWeaponType::Pistol;
                                        }
                                    }),
                                OutMontageDuration,
                                false
                            );
                        }
                    }),
                InMontageDuration,
                false
            );
        }
    }
 
    else if (IsWeaponMap.Contains(EWeaponType::Pistol) && IsWeaponMap.Num() > 0 && IsWeaponMap[EWeaponType::Pistol] == true)
    {
        if (WeaponChangeOutMontage)
        {
            FVector2D currentImagesize = WeaponIconImage->Brush.ImageSize;
            
            if (WeaponIconImage && WeaponIconImageMap[EWeaponType::Pistol] && WeaponIconImageMap.Num() > 0 && WeaponIconImageMap.Contains(EWeaponType::Pistol))
            {
                WeaponIconImage->SetBrushFromTexture(WeaponIconImageMap[EWeaponType::Pistol]);
                WeaponIconImage->SetBrushSize(currentImagesize);
            }
            
            if (CrossHairImage && WeaponCrosshairImageMap[EWeaponType::Pistol] && WeaponCrosshairImageMap.Num() > 0 && WeaponCrosshairImageMap.Contains(EWeaponType::Pistol))
            {
                CrossHairImage->SetBrushFromTexture(WeaponCrosshairImageMap[EWeaponType::Pistol]);
                CrossHairImage->SetBrushSize(currentImagesize);
            }
 
            UAnimInstance* AnimInstace = GetMesh()->GetAnimInstance();
            AnimInstace->Montage_Play(WeaponChangeOutMontage);
        }
        FTimerHandle HitDelayHandle;
        GetWorld()->GetTimerManager().SetTimer(HitDelayHandle,
            FTimerDelegate::CreateLambda([this]()
                {
                    if (WeaponChangeSound)
                    {
                        UGameplayStatics::PlaySound2D(this, WeaponChangeSound);
                        SM_PistolWeapon->SetVisibility(true);
                        UPlayerAnimInstance* playeranimInstance = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
                        playeranimInstance->WeaponTypeCount = 2;
                        currentWeapon = EWeaponType::Pistol;
                    }
                }),
            0.5f,
            false
        );
    }
    else//총이 없는경우++
    {
        UGameplayStatics::PlaySound2D(this, WeaponChangeSound);
    }
}
 
void APlayerCharacterControl::WeaponFireSound() // 사격 소리
{
    if (RifleSound)
    {
        UGameplayStatics::PlaySound2D(this, RifleSound);
 
        //FTimerHandle HitSoundDelayHandle; // 타이머를 제어하기 위한 핸들 변수 (타이머 취소, 타이머 상태 확인) 선언
        //GetWorld()->GetTimerManager().SetTimer(HitSoundDelayHandle, // Get world() 현재 객체가 속한 월드를 가져옴 / GetTimerManager() 타이머를 관리하는 시스템 / SetTimer() 타이머를 설정하고 일정 시간이 지나면 특정 작업을 실행
        //    FTimerDelegate::CreateLambda([this]() { // FTimerDelegate::CreateLambda() 람다변수를 타이머에 연결 가능한 델리게이트로 변환 / [this] 현재 클래스의 멤버 변수 함수에 접근하기 위한 캡쳐 / [=] 모든 외부에 있는 변수 값을 사용함 / () 안에는 내가 원하는 매개변수 삽입가능 / 오류 발생으로 코드 수정
        //        UGameplayStatics::PlaySound2D(this, HitSound);
        //    }),
        //    1.0f, // 1초 뒤
        //    false // 반복 x
        //    ); //소리가 2번 재생되므로 주석처리
        // 람다함수 간단한 함수를 선언 없이 즉석해서 만드는 방식 / [캡쳐](매개변수){실행코드};
    }
}
 
void APlayerCharacterControl::InitFindWeaponMesh()
{
    SM_RifleWeapon = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("RifleWeaponMesh")); // 무기 소켓 추가
    SM_RifleWeapon->SetupAttachment(GetMesh());
    static ConstructorHelpers::FObjectFinder<UStaticMesh>rifleWeaponMesh(TEXT("/Script/Engine.StaticMesh'/Game/Asset/FPS_Weapon_Bundle/Weapons/Meshes/AR4/SM_AR4.SM_AR4'")); // 무기 SM 가져옴
    if (rifleWeaponMesh.Succeeded()) // SM 체크
    {
        SM_RifleWeapon->SetStaticMesh(rifleWeaponMesh.Object);
 
    }
    SM_RifleWeapon->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform, TEXT("RifleWeapon_Socket")); // 소켓에 SM 장착
 
    SM_PistolWeapon = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("PistolWeaponMesh"));
    SM_PistolWeapon->SetupAttachment(GetMesh());
    static ConstructorHelpers::FObjectFinder<UStaticMesh> pistolweaponMesh(TEXT("/Script/Engine.StaticMesh'/Game/ATPS/Assets/Weapons/Pistol/Mesh/StaticMesh.StaticMesh'"));
    if (pistolweaponMesh.Succeeded())
    {
        SM_PistolWeapon->SetStaticMesh(pistolweaponMesh.Object);
    }
    SM_PistolWeapon->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform, TEXT("PistolWeapon_Socket"));
}
 
void APlayerCharacterControl::InitIsWeaponMap()
{
    IsWeaponMap.Add(EWeaponType::Pistol, false); // 아이템 확인
    IsWeaponMap.Add(EWeaponType::SMG, false);
    IsWeaponMap.Add(EWeaponType::Rifle, false);
    WeaponCrosshairImageMap.Add(EWeaponType::Pistol, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/Crosshair.Crosshair'"))); // 맵 사용 시 반드시 add로 초기화 해줘야함
    WeaponCrosshairImageMap.Add(EWeaponType::SMG, LoadObject<UTexture2D>(nullptr, TEXT("")));
    WeaponCrosshairImageMap.Add(EWeaponType::Rifle, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/rifle_crosshair.rifle_crosshair'")));
    WeaponIconImageMap.Add(EWeaponType::Pistol, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/pistol.pistol'")));
    WeaponIconImageMap.Add(EWeaponType::SMG, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/smg.smg'")));
    WeaponIconImageMap.Add(EWeaponType::Rifle, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/rifle.rifle'")));
}
 
void APlayerCharacterControl::InitFindInput()
{
    static ConstructorHelpers::FObjectFinder<UInputMappingContext>InputContext(TEXT("/Script/EnhancedInput.InputMappingContext'/Game/Input/IMC_PlayerInput.IMC_PlayerInput'")); // IMC 지정
    if (InputContext.Object != nullptr)
    {
        DefaultContext = InputContext.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction>InputMove(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/IA_Move.IA_Move'")); // IA_Move 지정
    if (InputMove.Object != nullptr)
    {
        MoveAction = InputMove.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction>InputLook(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/IA_Look.IA_Look'")); // IA_Look 지정
    if (InputLook.Object != nullptr)
    {
        LookAction = InputLook.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction>InputAim(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/IA_Aim.IA_Aim'")); // IA_Aim 지정; OnAim, OffAim 따로 지정해주지 않아도 됨
    if (InputAim.Object != nullptr)
    {
        AimAction = InputAim.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction>InputFire(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/IA_Fire.IA_Fire'")); // IA_Fire 지정
    if (InputFire.Object != nullptr)
    {
        FireAction = InputFire.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction>InputOperate(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/IA_Operate.IA_Operate'")); // IA_Operate 지정
    if (InputOperate.Object != nullptr)
    {
        OperateAction = InputOperate.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction>InputRifleChange(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/IA_RifleChange.IA_RifleChange'")); // IA_RifleChange 지정
    if (InputRifleChange.Object != nullptr)
    {
        RifleChangeAction = InputRifleChange.Object;
    }
 
 
    static ConstructorHelpers::FObjectFinder<UInputAction>InputPistolChange(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/IA_PistolChange.IA_PistolChange'")); // IA_PistolChange 지정
    if (InputPistolChange.Object != nullptr)
    {
        PistolChangeAction = InputPistolChange.Object;
    }
}
 
void APlayerCharacterControl::InitFindWidget()
{
    if (HUDClass == nullptr)
    {
        HUDClass = LoadClass<UUserWidget>(nullptr, TEXT("/Game/UMG/WB_PlayerHUD.WB_PlayerHUD'_C"));
    }
    
    /*static ConstructorHelpers::FClassFinder<UUserWidget>HUD(TEXT("WidgetBlueprint'/Game/UMG/WB_PlayerHUD.WB_PlayerHUD'_C'"));
    
    if (HUD.Succeeded())
    {
        HUDClass = HUD.Class;
    }*/
}

DoorManager.h

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "DoorManager.generated.h"
 
UCLASS()
class MYPROJECT_API ADoorManager : public AActor
{
    GENERATED_BODY()
    
public:    
    // Sets default values for this actor's properties
    ADoorManager();
 
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;
 
public:    
    // Called every frame
    virtual void Tick(float DeltaTime) override;
 
public:
 
    void DoorOpen();
 
    UFUNCTION(BlueprintImplementableEvent)
    void DoorOpen_BP();
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    USoundBase* DoorOpenSound;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    USoundBase* DoorCloseSound;
};

DoorManager.cpp

// Fill out your copyright notice in the Description page of Project Settings.
 
 
#include "DoorManager.h"
#include "Kismet/GameplayStatics.h" // 소리 추가 시 추가
 
// Sets default values
ADoorManager::ADoorManager()
{
     // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
 
}
 
// Called when the game starts or when spawned
void ADoorManager::BeginPlay()
{
    Super::BeginPlay();
    
}
 
// Called every frame
void ADoorManager::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
}
 
void ADoorManager::DoorOpen()
{
    DoorOpen_BP();
 
    // 이렇게 설정하는게 맞으나 일단은 주석처리
    //float VolumeMultiplier = 1.0f; // 소리 볼륨 배율
    //float PitchMultiplier = 1.0f; // 소리 피치 배율
    //float StartTime = 0.0f; // 소리 재생 시작 시간
    //USoundAttenuation* AttenuationSettings = nullptr; // 사운드 감쇠 설정
    //USoundConcurrency* ConcurrencySettings = nullptr; // 사운드 동시성 설정
 
    //UGameplayStatics::PlaySoundAtLocation (GetWorld(), DoorOpenSound, GetActorLocation(), VolumeMultiplier, PitchMultiplier, StartTime, AttenuationSettings, ConcurrencySettings);
}