Unreal Engine 5 배워보기 - 45일차

컴퓨터 및 게임 관련 전공인이 아닌 문외한 일반인이 언리얼 엔진을 배우면서 정리한 내용입니다.

그날그날 배웠던 내용을 제가 나중에 보기 위해 정리한 것으로, 지금 당장 보기에 부족한 점이 아주아주 많고 추후에 수정이 될 수도 있습니다.

오탈자 및 잘못 기재된 내용 지적, 부족한 내용 설명은 언제든지 환영입니다.

 

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

 

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

 

45일차 학습 내용

- 사다리

- Swimming

- Elevator

 

 

사다리

사다리는 문 못지 않게 구현이 까다로운 상호작용 가능한 오브젝트 중 하나이다.

상호작용 키를 누르면 사다리를 타는 애니메이션을 재생시키면서 목적지까지 이동시키고, 사다리 타는 것을 종료하면 다시 조종 가능한 상태로 가능하도록 바꿔주는 방식을 일반적으로 많이 사용하지만, 사다리 타도 상하로 플레이어의 조종이 가능하도록 넣는 경우도 적지 않다.

이번에는 간단하게 사다리를 탈 수 있도록 사다리를 생생해보도록 하겠다.

사다리를 타려면 우선 플레이어가 사다리라는 것을 인식해야한 뒤 사다리를 타는 상태로 바꿔야하며, 사다리를 타고 이동할 경우 좌우로 움직이는 Input은 없애주고 상하로 이동하는 Input만 남겨둬야 한다.

우선은 사다리 액터 BP를 생성해주도록 한다.

위 그림과 같이 사다리의 자식으로 Box Collision을 생성하고 위 그림과 같이 딱 사다리를 타는 곳에 맞게 딱 붙여준다.

Box Collision에 플레이어가 부딪히면 플레이어를 사다리를 타는 상태로 바꿔주기 위해 우선은 변수를 추가해준다.

PlayerControl.h

public: //===================PlayerState=========================
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    bool isItem = false;
 
    bool isAim = false;
 
    float PlayerHp = 100;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PlayerState")
    bool isLadder; // 사다리 타는 상태 변수 추가

그리고 위 그림과 같이 BP를 작성해주면, 플레이어가 사다리에 달린 Collision에 부딪히면 사다리 타는 상태가 되고, Collision에서 멀어지면 사다리 타지 않는 상태가 된다.

사다리 타는 상태와 타지 않는 상태를 구분했으니, 이젠 사다리에서 상하로 움직이는 조작만 추가해주면 된다.

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

PlayerControl.cpp

#include "GameFrameWork/CharacterMovementComponent.h" // 추가
 
.
.
.
 
void APlayerCharacterControll::Move(const FInputActionValue& value)
{
    const FVector2D MovementVector = value.Get<FVector2D>();
    const FRotator Rotation = Controller->GetControlRotation();
    const FRotator YawRotation(0, Rotation.Yaw, 0);
 
    const FVector ForwardDiretion = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
 
    AddMovementInput(ForwardDiretion, MovementVector.Y);
    
    if (!isLadder) // 사다리를 타는 상태가 아닐 경우
    {
        GetCharacterMovement()->SetMovementMode(MOVE_Walking); // 캐릭터 이동 상태 결정
        AddMovementInput(RightDirection, MovementVector.X);
    }
    else // 사다리를 타는 상태일 경우
    {
        GetCharacterMovement()->SetMovementMode(MOVE_Flying);
        const FVector LadderUpDirection = FVector::UpVector; // 월드 좌표 기준 z축 방향
        AddMovementInput(LadderUpDirection, MovementVector.Y);
    }
}

사다리를 타는 상태가 아닐 경우 플레이어를 걷기 상태로 만들며 Input을 받아 이동하는 상태로 해줬고, 사다리를 타는 상태일 경우 플레이어를 나는 상태로 만들며 기존에 앞뒤로 이동하던 'w' , 's' 키를 상하로 움직이도록 바꿔주었다.

게임을 실행해보면 위 그림과 같이 사다리를 탄 상태가 됐을 경우, w키를 누르면 사다리를 타고 위로 올라가며 좌우로 이동하는 조작은 동작하지 않는 것을 확인할 수 있다.

Swimming

이번에는 플레이어를 수영하는 상태러 만들어보도록 하겠다.

우선은 43일 차에서 사용했던 Water Plugin을 추가해준다.

Plugin 추가가 되면 "Place Actor" 탭에서 "Water" 을 검색하여 "Water Body Ocean" 을 레벨에 배치해준다.

그러면 위 그림과 같이 레벨 전체에 걸쳐서 배치되는 것을 확인할 수 있다.

하얀색 선의 Spline의 Segment를 당겨서 기존에 배치된 Plane에 맞게 크기를 줄여주면 위 그림과 같이 Plane 주위에 물이 배치되게 된다.

우측 "Details" 탭에서 "Add" 를 눌러 위 그림과 같이 "WaterBodyOcean" 의 BP를 생성해준다.

위에서 생성해준 BP로 들어가 "WaterBodyOcean" 에 Overlap 되는 이벤트를 생성하여 위 그림과 같이 BP를 작성해준다.

플레이어가 "WaterBodyOcean" 과 충돌했을 경우 수영하는 상태로 만들고, "WaterBodyOcean" 에서 벗어나면 걷기 상태로 만들어주는 BP이다.

허나 이렇게 했을 경우 메세지가 뜨지 않는 것을 확인할 수 있다.

"WaterBodyOcean" 자체에는 Collision이 없기 때문에 그런 것이다.

이번엔 Box Collision을 추가하여 위 그림과 같이 Box Collision에 Overlap 되는 이벤트를 생성해준다.

Box Collision을 레벨에 배치해준 뒤 게임을 실행해보면 아래 그림과 같이 이번엔 메세지가 출력되는 것을 확인할 수 있다.

메세지가 정상 출력된다는 것은 플레이어의 움직임 상태도 설정한 대로 변화되고 있다는 것을 의미한다.

"Water Body Ocean" 을 사용할 경우 별도의 Collision을 설치하여 플레이어의 움직임 상태를 변경시켜줘야한다.

 

Elevator

이번엔 간단한 Elevator를 만들어보도록 하겠다.

우선 Elevator 액터 BP를 생성하여 위 그림과 같이 엘레베이터와 비슷하게 만들어주고, 엘레베이터를 동작 가능하도록 하는 스위치도 생성해준다.

스위치를 동작하게 하려면 플레이어의 상호작용 버튼을 눌러서 동작하도록 해줄 생각이기에, 플레이어의 상호작용 버튼과 충돌이 가능한 "Item" 으로 버튼의 Spherer Collision의 프리셋을 설정해준다.

Event Graph로 이동하여 위 그림과 같이 Custom Event를 생성해준다.

Custom Event 함수를 실행하면, 소리를 재생하며 엘레베이터를 z축 값 300으로 이동시키고 z축 값 0으로 이동시키게 된다.

그리고 아래와 같이 코드를 추가해준다.

PlayerControl.cpp

void APlayerCharacterControll::Operate()
{
 
.
.
.
 
        else if (name == TEXT("Elevator"))
        {
            AActor* Actor = HitResult.GetActor();
            UFunction* ElevatorEvent = Actor->FindFunction(FName("ElevatorEvent")); // 함수를 찾아 실행
            if (ElevatorEvent)
            {
                Actor->ProcessEvent(ElevatorEvent, nullptr);
            }
            return;
        }
 
.
.
.
    
}

플레이어의 상호작용 버튼이 "Elevator" 라는 오브젝트와 부딪히면, "ElevatorEvent" 함수를 실행하도록 하고, 'Operate' 함수의 그 이하는 실행하지 않도록 하는 것이다.

이렇게 하고 게임을 실행할 경우, 버튼 근처에서 플레이어가 상호작용 버튼을 누르면 엘레베이터가 z축 300값, 0값으로 정상적으로 이동하나, 움직임이 많이 딱딱한 것을 확인할 수 있다.

이 경우 위 그림과 같이 Timeline을 추가하여 연결해주면 아래 움짤과 같이 부드럽게 위아래로 이동하는 것을 확인할 수 있다.

2배속

상호작용 버튼을 눌렀을 때 엘레베이터 자체가 사라지는 경우도 있는데, 그 경우는 코드 상에 보이는 "Elevator" 라는 개체를 찾지 못해서 "return" 이 실행되지 않아 아이템을 습득했을 때처럼 사라져버리는 것이다.

이 경우에는 반드시 위 그림과 같이 "DefaultSceneRoot" 하위 개체로 "DefaultSceneRoot" 를 하나 더 추가해서 이름을 "Elevator" 로 명명해줘야한다.

엘리베이터의 버튼을 눌렀을 때 이름이 "Elevator" 가 나오도록 하려면, 별도의 "SceneComponent" 에 엘리베이터를 이루는 부속품들을 묶어줘야 하기 때문이다.

 

 

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

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"
#include "Components/TextBlock.h"
#include "Blueprint/UserWidget.h"
#include "NiagaraSystem.h"
#include "NiagaraFunctionLibrary.h"
#include "PlayerCharacterControll.generated.h"
 
UENUM()
enum class EWeaponType : uint8
{
    None UMETA(DisplayName = "None"),
    Pistol UMETA(DisplayName = "Pistol"),
    SMG UMETA(DisplayName = "SMG"),
    Rifle UMETA(DisplayName = "Rifle"),
};
 
 
UCLASS()
class SILENTHILL_API APlayerCharacterControll : public ACharacter
{
    GENERATED_BODY()
 
public:
    APlayerCharacterControll();
 
protected:
    virtual void BeginPlay() override;
 
public:    
    virtual void Tick(float DeltaTime) override;
 
    virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
 
protected: //===================Camera=========================
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    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(EditAnywhere, Category = "Input")
    float mouseSpeed = 30.0f;
 
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 InitializationFindInput();
    void InitializationFindWeaponMesh();
    void InitializationIsWeaponMap();
    void InitializationFindWidget();
    virtual float TakeDamage
    (float DamageAmount, struct FDamageEvent const& DamageEvent, 
        class AController* EventInstigator, AActor* DamageCauser) override;
    virtual void PlayHitFX(FVector HitLocation, FRotator HitRotator, FVector FXScale);
 
 
public: //===================Montage=========================
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animation")
    UAnimMontage* RifleAimMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animation")
    UAnimMontage* RifleFireMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animation")
    UAnimMontage* PistolAimMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animation")
    UAnimMontage* PistolFireMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animation")
    UAnimMontage* OperateMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animation")
    UAnimMontage* WeaponChangeInMontage;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animation")
    UAnimMontage* WeaponChangeOutMontage;
 
public://===================Sound=========================
    UPROPERTY(EditAnywhere, Category = "Sound")
    USoundBase* RifleSound;
 
    UPROPERTY(EditAnywhere, Category = "Sound")
    USoundBase* HitSound;
 
    UPROPERTY(EditAnywhere, Category = "Sound")
    USoundBase* WeaponChangeSound;
 
    void WeaponFireSound();
 
public://===================Weapon=========================
    UPROPERTY(EditAnywhere)
    class UStaticMeshComponent* SM_RifleWeapon;
 
    UPROPERTY(EditAnywhere)
    class UStaticMeshComponent* SM_PistolWeapon;
 
    UPROPERTY(EditAnywhere)
    class UStaticMeshComponent* SM_SMGWeapon;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    EWeaponType currentWeapon = EWeaponType::None;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    TMap<EWeaponType, bool> IsWeaponMap;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    int RifleBulletCount = 30;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    int PistolBulletCount = 15;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    int SMGBulletCount = 30;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly) //장전된 총알
    int CurrentBulletCount = 0;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly) //가지고 있는 총알
    int SaveBulletCount = 0;
 
public://===================Blueprint=========================
    UFUNCTION(BlueprintImplementableEvent, Category = "Blueprint")
    void OnFire_BP();
 
    UFUNCTION(BlueprintImplementableEvent, Category = "Blueprint")
    void OnAim_BP();
 
    UFUNCTION(BlueprintImplementableEvent, Category = "Blueprint")
    void OffAim_BP();
    
    UFUNCTION(BlueprintImplementableEvent, Category = "Blueprint")
    void Operate_BP();
 
public: //===================PlayerState=========================
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    bool isItem = false;
 
    bool isAim = false;
 
    float PlayerHp = 100;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "PlayerState")
    bool isLadder;
 
public: //===================CameraShake=========================
    UPROPERTY(EditAnywhere)
    TSubclassOf<class UCameraShakeBase> RifleFireCameraShakeClass;
 
    UPROPERTY(EditAnywhere)
    TSubclassOf<class UCameraShakeBase> PlayerDamageCameraShakeClass;
 
public: //===================Widget==============================
    UPROPERTY(EditAnywhere, Category = "Widget")
    TSubclassOf<class UUserWidget> HUDClass = nullptr;
 
    UPROPERTY()
    UUserWidget* HUDWidget;
 
    UImage* CrossHairImage;
    UImage* WeaponIconImage;
    UTextBlock* BulletCountTextBlock;
    UTextBlock* HpTextBlock;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    TMap<EWeaponType, UTexture2D*> WeaponCrossHairImageMap;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly)
    TMap<EWeaponType, UTexture2D*> WeaponIconImageMap;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FX")
    TArray<UNiagaraSystem*> HitFXArray;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "FX")
    TArray<UParticleSystem*> HitParticleSystemArray;
};

PlayerControl.cpp

// Fill out your copyright notice in the Description page of Project Settings.
 
 
#include "PlayerCharacterControll.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"
#include "DoorManager.h"
#include "Particles/ParticleSystem.h"
#include "GameFrameWork/CharacterMovementComponent.h"
 
// Sets default values
APlayerCharacterControll::APlayerCharacterControll()
{
     // 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"));
    SpringArm->SetupAttachment(RootComponent);
    SpringArm->SetWorldLocation(FVector(0, 0, 65.0f));
    SpringArm->TargetArmLength = 150;
    SpringArm->SocketOffset = FVector(0, 40, 0);
    SpringArm->bUsePawnControlRotation = true;
 
    Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
    Camera->SetupAttachment(SpringArm);
    
    static ConstructorHelpers::FClassFinder<UAnimInstance> AnimInstance(TEXT("/Game/Blueprints/ABP_Player.ABP_Player_C"));
 
    if (AnimInstance.Class)
    {
        GetMesh()->SetAnimInstanceClass(AnimInstance.Class);
    }
    InitializationFindWeaponMesh();
    InitializationFindInput();
}
 
void APlayerCharacterControll::BeginPlay()
{
    Super::BeginPlay();
 
    InitializationFindWidget();
    InitializationIsWeaponMap();
 
    if (APlayerController* PlayerController = Cast<APlayerController>(GetController()))
    {
        if (UEnhancedInputLocalPlayerSubsystem* SubSystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
        {
            SubSystem->AddMappingContext(DefaultContext, 0);
        }
    }
    //SM_Weapon->bHiddenInGame = true;
    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")));
        HpTextBlock = Cast<UTextBlock>(HUDWidget->GetWidgetFromName(TEXT("HpText")));
        if (CrossHairImage)
        {
            CrossHairImage->SetVisibility(ESlateVisibility::Hidden);
        }
        if (WeaponIconImage)
        {
            WeaponIconImage->SetVisibility(ESlateVisibility::Hidden);
        }
        if (BulletCountTextBlock)
        {
            BulletCountTextBlock->SetVisibility(ESlateVisibility::Hidden);
        }
        if (HpTextBlock)
        {
            HpTextBlock->SetVisibility(ESlateVisibility::Hidden);
        }
    }
}
 
void APlayerCharacterControll::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
}
 
void APlayerCharacterControll::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);
    EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &APlayerCharacterControll::Move);
    EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &APlayerCharacterControll::Look);
    EnhancedInputComponent->BindAction(AimAction, ETriggerEvent::Started, this, &APlayerCharacterControll::OnAim);
    EnhancedInputComponent->BindAction(AimAction, ETriggerEvent::Completed, this, &APlayerCharacterControll::OffAim);
    EnhancedInputComponent->BindAction(FireAction, ETriggerEvent::Started, this, &APlayerCharacterControll::Fire);
    EnhancedInputComponent->BindAction(OperateAction, ETriggerEvent::Started, this, &APlayerCharacterControll::Operate);
    EnhancedInputComponent->BindAction(RifleChangeAction, ETriggerEvent::Started, this, &APlayerCharacterControll::RifleMode);
    EnhancedInputComponent->BindAction(PistolChangeAction, ETriggerEvent::Started, this, &APlayerCharacterControll::PistolMode);
}
 
void APlayerCharacterControll::Move(const FInputActionValue& value)
{
    const FVector2D MovementVector = value.Get<FVector2D>();
    const FRotator Rotation = Controller->GetControlRotation();
    const FRotator YawRotation(0, Rotation.Yaw, 0);
 
    const FVector ForwardDiretion = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
 
    AddMovementInput(ForwardDiretion, MovementVector.Y);
    
    if (!isLadder)
    {
        GetCharacterMovement()->SetMovementMode(MOVE_Walking);
        AddMovementInput(RightDirection, MovementVector.X);
    }
    else
    {
        GetCharacterMovement()->SetMovementMode(MOVE_Flying);
        const FVector LadderUpDirection = FVector::UpVector; // z축 방향
        AddMovementInput(LadderUpDirection, MovementVector.Y);
    }
}
 
void APlayerCharacterControll::Look(const FInputActionValue& value)
{
    FVector2D LookAxisVector = value.Get<FVector2D>();
 
    AddControllerYawInput(LookAxisVector.X * GetWorld()->DeltaTimeSeconds * mouseSpeed);
    AddControllerPitchInput(LookAxisVector.Y * GetWorld()->DeltaTimeSeconds * -mouseSpeed);
}
 
void APlayerCharacterControll::OnAim()
{
    if(IsWeaponMap.Num() > 0)
    {
        if (CrossHairImage)
        {
            CrossHairImage->SetVisibility(ESlateVisibility::Visible);
        }
        if (WeaponIconImage)
        {
            WeaponIconImage->SetVisibility(ESlateVisibility::Visible);
        }
        if (BulletCountTextBlock)
        {
            BulletCountTextBlock->SetVisibility(ESlateVisibility::Visible);
        }
        if (HpTextBlock)
        {
            HpTextBlock->SetVisibility(ESlateVisibility::Visible);
        }
        
        if (IsWeaponMap.Contains(EWeaponType::Rifle) && currentWeapon == EWeaponType::Rifle)
        {
            OnAim_BP();
            UPlayerAnimInstance* animInstace = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
            isAim = true;
            animInstace->isAim = true;
            CurrentBulletCount = RifleBulletCount;
            //무기상태를 애니인스턴스한테 전달하기
        }
        else if (IsWeaponMap.Contains(EWeaponType::Pistol) && currentWeapon == EWeaponType::Pistol)
        {
            OnAim_BP();
            UPlayerAnimInstance* animInstace = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
            isAim = true;
            animInstace->isAim = true;
            CurrentBulletCount = PistolBulletCount;
            //무기상태를 애니인스턴스한테 전달하기
        }
        else if (IsWeaponMap.Contains(EWeaponType::SMG) && currentWeapon == EWeaponType::SMG)
        {
            OnAim_BP();
            UPlayerAnimInstance* animInstace = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
            isAim = true;
            animInstace->isAim = true;
            CurrentBulletCount = SMGBulletCount;
            //무기상태를 애니인스턴스한테 전달하기
        }
 
        //AsNumber()를 사용해서 int32를 FText로 변환
        FText currentBullet = FText::AsNumber(CurrentBulletCount);
        FText saveBullet = FText::AsNumber(SaveBulletCount);
 
        FText text = FText::Format(FText::FromString(TEXT("{0}/{1}")), currentBullet, saveBullet);
        
        BulletCountTextBlock->SetText(text);
    }
}
 
void APlayerCharacterControll::OffAim()
{
    if (CrossHairImage)
    {
        CrossHairImage->SetVisibility(ESlateVisibility::Hidden);
    }
    if (WeaponIconImage)
    {
        WeaponIconImage->SetVisibility(ESlateVisibility::Hidden);
    }
    if (BulletCountTextBlock)
    {
        BulletCountTextBlock->SetVisibility(ESlateVisibility::Hidden);
    }
    if (HpTextBlock)
    {
        HpTextBlock->SetVisibility(ESlateVisibility::Hidden);
    }
    OffAim_BP();
    UPlayerAnimInstance* animInstace = Cast<UPlayerAnimInstance>(GetMesh()->GetAnimInstance());
    animInstace->isAim = false;
    isAim = false;
}
 
void APlayerCharacterControll::Fire()
{
    if (isAim)
    {
        float Damage = 10;
        if (currentWeapon == EWeaponType::Rifle && RifleBulletCount > 0)
        {
            CurrentBulletCount--;
            RifleBulletCount = CurrentBulletCount;
            
            if (RifleFireCameraShakeClass)
            {
                GetWorld()->GetFirstPlayerController()->ClientStartCameraShake(RifleFireCameraShakeClass);
            }
        }
        else if (currentWeapon == EWeaponType::Pistol && PistolBulletCount > 0)
        {
            CurrentBulletCount--;
            PistolBulletCount = CurrentBulletCount;
            Damage = FMath::RandRange(5, 10);
        }
        else if (currentWeapon == EWeaponType::SMG && SMGBulletCount > 0)
        {
            CurrentBulletCount--;
            SMGBulletCount = CurrentBulletCount;
            Damage = FMath::RandRange(2, 5);
        }
        
        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_GameTraceChannel4))
        {
            UGameplayStatics::ApplyDamage(Hit.GetActor(), Damage, Hit.GetActor()->GetInstigatorController(), Hit.GetActor(), NULL);
            //Hit.GetActor()->Destroy();
        }
 
        UAnimInstance* AnimInstace = GetMesh()->GetAnimInstance();
        if (RifleFireMontage)
        {
            AnimInstace->Montage_Play(RifleFireMontage, 0.233333f);
        }
        FTimerHandle HitSoundDelayHandle;
        GetWorld()->GetTimerManager().SetTimer(HitSoundDelayHandle, this,
            &APlayerCharacterControll::WeaponFireSound,
            0.2f,
            false
        );
    }
    FText currentBullet = FText::AsNumber(CurrentBulletCount);
    FText saveBullet = FText::AsNumber(SaveBulletCount);
 
    FText text = FText::Format(FText::FromString(TEXT("{0}/{1}")), currentBullet, saveBullet);
 
    BulletCountTextBlock->SetText(text);
}
 
void APlayerCharacterControll::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_GameTraceChannel8, FCollisionShape::MakeSphere(SphereRadius), Params);
    DrawDebugSphere(GetWorld(), StartLocation, SphereRadius, 12, FColor::Red, false, 1.0f);
    if (isHit)
    {
        FString name = HitResult.GetActor()->GetName();
        name = name.LeftChop(name.Len() - name.Find(TEXT("_C_1"))); //10 - 6 = 4
        name = name.RightChop(3);
        GEngine->AddOnScreenDebugMessage(-1, 3.0f, FColor::Blue, FString::Printf(TEXT("%s"), *name));
 
 
        if (name == TEXT("WeaponPistol"))
        {
            IsWeaponMap[EWeaponType::Pistol] = true;
        }
        else if (name == TEXT("WeaponSMG"))
        {
            IsWeaponMap[EWeaponType::SMG] = true;
        }
        else if (name == TEXT("WeaponRifle"))
        {
            IsWeaponMap[EWeaponType::Rifle] = true;
        }
        else if (name == TEXT("RifleBullet"))
        {
            RifleBulletCount += 30;
            if (RifleBulletCount >= 200)
            {
                RifleBulletCount = 200;
            }
        }
        else if (name == TEXT("PistolBullet"))
        {
            PistolBulletCount += 15;
            if (PistolBulletCount >= 120)
            {
                PistolBulletCount = 120;
            }
        }
        else if (name == TEXT("SMGBullet"))
        {
            SMGBulletCount += 30;
            if (SMGBulletCount >= 150)
            {
                SMGBulletCount = 150;
            }
        }
        else if (name == TEXT("Door1"))
        {
            ADoorManager* doorManager = Cast<ADoorManager>(HitResult.GetActor());
            if (doorManager)
            {
                doorManager->DoorOpen();
            }
            return;
        }
        else if (name == TEXT("Elevator"))
        {
            AActor* Actor = HitResult.GetActor();
            UFunction* ElevatorEvent = Actor->FindFunction(FName("ElevatorEvent"));
            if (ElevatorEvent)
            {
                Actor->ProcessEvent(ElevatorEvent, nullptr);
            }
            return;
        }
        FTimerHandle HitDelayHandle;
        GetWorld()->GetTimerManager().SetTimer(HitDelayHandle,
            FTimerDelegate::CreateLambda([HitResult]()
                {
                    HitResult.GetActor()->Destroy();
                }),
            0.5f,
            false
        );
    }
}
 
void APlayerCharacterControll::RifleMode()
{
    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);
            }
 
            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_PistolWeapon->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_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)
        {
            if (WeaponIconImage && WeaponIconImageMap[EWeaponType::Rifle] && WeaponIconImageMap.Num() > 0 && WeaponIconImageMap.Contains(EWeaponType::Rifle))
            {
                WeaponIconImage->SetBrushFromTexture(WeaponIconImageMap[EWeaponType::Rifle]);
            }
            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 APlayerCharacterControll::PistolMode()
{
    if (IsWeaponMap.Num() > 0 && currentWeapon == EWeaponType::Rifle&& IsWeaponMap.Contains(EWeaponType::Pistol))
    {
        if (WeaponChangeInMontage)
        {
            if (WeaponIconImage && WeaponIconImageMap[EWeaponType::Pistol] && WeaponIconImageMap.Num() > 0 && WeaponIconImageMap.Contains(EWeaponType::Pistol))
            {
                WeaponIconImage->SetBrushFromTexture(WeaponIconImageMap[EWeaponType::Pistol]);
            }
            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)
        {
            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 APlayerCharacterControll::WeaponFireSound()
{
    if (RifleSound)
    {
        UGameplayStatics::PlaySound2D(this, RifleSound);
 
    }
}
 
void APlayerCharacterControll::InitializationFindInput()
{
 
    static ConstructorHelpers::FObjectFinder<UInputMappingContext> InputContext(TEXT("/Script/EnhancedInput.InputMappingContext'/Game/Input/IMC_PlayerInput.IMC_PlayerInput'"));
    if (InputContext.Object != nullptr)
    {
        DefaultContext = InputContext.Object;
    }
    static ConstructorHelpers::FObjectFinder<UInputAction> InputMove(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/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'"));
    if (InputLook.Object != nullptr)
    {
        LookAction = InputLook.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction> InputAim(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/IA_Aim.IA_Aim'"));
    if (InputAim.Object != nullptr)
    {
        AimAction = InputAim.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction> InputFire(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/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'"));
    if (InputOperate.Object != nullptr)
    {
        OperateAction = InputOperate.Object;
    }
 
    static ConstructorHelpers::FObjectFinder<UInputAction> InputRifleChange(TEXT("/Script/EnhancedInput.InputAction'/Game/Input/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'"));
    if (InputPistolChange.Object != nullptr)
    {
        PistolChangeAction = InputPistolChange.Object;
    }
}
 
void APlayerCharacterControll::InitializationFindWeaponMesh()
{
 
    SM_RifleWeapon = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("RifleWeaponMesh"));
    SM_RifleWeapon->SetupAttachment(GetMesh());
    static ConstructorHelpers::FObjectFinder<UStaticMesh> rifleWeaponMesh(TEXT("/Script/Engine.StaticMesh'/Game/Asset/Weapons/FPS_Weapon_Bundle/Weapons/Meshes/AR4/SM_AR4.SM_AR4'"));
    if (rifleWeaponMesh.Succeeded())
    {
        SM_RifleWeapon->SetStaticMesh(rifleWeaponMesh.Object);
    }
 
    SM_RifleWeapon->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform, TEXT("RifleWeapon_Socket"));
 
 
    SM_PistolWeapon = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("PistolWeaponMesh"));
    SM_PistolWeapon->SetupAttachment(GetMesh());
    static ConstructorHelpers::FObjectFinder<UStaticMesh> pistolweaponMesh(TEXT("/Script/Engine.StaticMesh'/Game/Asset/PistolStaticMesh.PistolStaticMesh'"));
    if (pistolweaponMesh.Succeeded())
    {
        SM_PistolWeapon->SetStaticMesh(pistolweaponMesh.Object);
    }
    SM_PistolWeapon->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform, TEXT("PistolWeapon_Socket"));
}
 
void APlayerCharacterControll::InitializationIsWeaponMap()
{
    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'")));
    WeaponCrossHairImageMap.Add(EWeaponType::Rifle, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/crosshair.crosshair'")));
    WeaponCrossHairImageMap.Add(EWeaponType::SMG, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/crosshair.crosshair'")));
    WeaponIconImageMap.Add(EWeaponType::Pistol, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/PistolIcon.PistolIcon'")));
    WeaponIconImageMap.Add(EWeaponType::Rifle, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/RifleIcon.RifleIcon'")));
    WeaponIconImageMap.Add(EWeaponType::SMG, LoadObject<UTexture2D>(nullptr, TEXT("/Script/Engine.Texture2D'/Game/UMG/Texture/PistolIcon.PistolIcon'")));
}
 
void APlayerCharacterControll::InitializationFindWidget()
{
 
    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;
    }*/
}
 
float APlayerCharacterControll::TakeDamage(float DamageAmount, FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser)
{
    const float Damage = Super::TakeDamage(DamageAmount, DamageEvent, EventInstigator, DamageCauser);
    
    GEngine->AddOnScreenDebugMessage(-1, 3.0f, FColor::Red, FString::Printf(TEXT("Player Damage : %f"), Damage));
    
    if (Damage > 0)
    {
        PlayerHp -= Damage;
        if (Damage >= 40 /* && 몽타지가 있으면*/) //강공격
        {
            //GetMesh()->GetAnimInstance()->Montage_Play();
            UGameplayStatics::PlaySound2D(GetWorld(), HitSound);
        }
        else //기본공격
        {
            //GetMesh()->GetAnimInstance()->Montage_Play();
            UGameplayStatics::PlaySound2D(GetWorld(), HitSound);
        }
        
        if (PlayerHp <= 0)
        {
            //GetMesh()->GetAnimInstance()->Montage_Play();
            //UI HP 강제 0 설정
            return Damage;
        }
        if (HpTextBlock)
        {
            FText Hp = FText::AsNumber(PlayerHp);
            HpTextBlock->SetText(Hp);
            HpTextBlock->SetVisibility(ESlateVisibility::Visible);
        }
        FVector FXScale = FVector(1, 1, 1);
        PlayHitFX(GetActorLocation(), GetActorRotation(), FXScale);
        if (PlayerDamageCameraShakeClass)
        {
            GetWorld()->GetFirstPlayerController()->ClientStartCameraShake(PlayerDamageCameraShakeClass);
        }
 
    }
    return Damage;
}
 
void APlayerCharacterControll::PlayHitFX(FVector HitLocation, FRotator HitRotator, FVector FXScale)
{
    if (HitFXArray.Num() > 0)
    {
        int32 RandomIndex = FMath::RandRange(0, HitFXArray.Num() - 1);
        UNiagaraSystem* SelectedFX = HitFXArray[RandomIndex];
 
        if (SelectedFX)
        {
            UNiagaraFunctionLibrary::SpawnSystemAtLocation(GetWorld(), SelectedFX, HitLocation);
        }
    }
 
    if (HitParticleSystemArray.Num() > 0)
    {
        int32 RandomIndex = FMath::RandRange(0, HitParticleSystemArray.Num() - 1);
        UParticleSystem* SelectedFX = HitParticleSystemArray[RandomIndex];
 
        if (SelectedFX)
        {
            UGameplayStatics::SpawnEmitterAtLocation(GetWorld(), SelectedFX, HitLocation, HitRotator, FXScale);
        }
    }
}