06.23 Unreal 본캠프) 충돌 이벤트로 획득되는 아이템 구현하기

 

오늘 배운 것

 

1. 충돌 이벤트로 획득되는 아이템 구현하기

 1) 충돌 (Collision) 이벤트 기반 아이템 획득 방식 이해하기

 : 언리얼 엔진에서 아이템을 "플레이어가 가까이 다가가기만 해도 자동으로 획득" 시키고 싶다면, 보통 콜리전 (충돌) 이벤트를 사용한다.

   충돌 영역을 설정해두면, 플레이어가 그 영역 안에 들어오거나 나갈 때 자동으로 이벤트를 발생시켜주기 때문에 별도의 함수 호출 없이도 간편하게 처리할 수 있다.

- 충돌 영역 (Collision Volume)
 : 아이템 액터 주변에 SphereComponent 나 BoxComponent 같은 충돌 컴포넌트를 붙여둔다.
   플레이어가 이 영역 안에 들어오면 Overlap 이벤트가 발생하고, 이를 감지해 아이템 획득 로직을 실행할 수 있다.
- Overlap 이벤트 vs Hit 이벤트
   - Overlap 이벤트
      : 물리적으로 부딪히는 것 없이 액터들이 서로 "겹치기 시작" 했을 때 발생한다.
        아이템 획득, 트리거 존 감지 같은 경우에 주로 사용한다.
   - Hit 이벤트
      : 실제 물리 충돌이 일어날 때 발생한다. (예 : 탄환이 벽에 부딪히는 장면)
        아이템 획득처럼 "겹침" 만 감지하면 되는 경우에는 Overlap 이벤트가 더욱 적합하다.
- 아이템 획득 처리
 : 충돌 영역 안에 플레이어가 들어오면 (Overlap 시작 시점), 아이템이 즉시 사라지거나(DestroyItem()), 점수를 올리거나 체력을 회복하는 등 다양한 로직을 실행할 수 있다. 
   초중급 개발에서 많이 쓰이느 방식으로, 한 번 제대로 설정해두면 매우 편하게 사용할 수 있다.

 

 2) 기본 아이템 클래스 (BaseItem) 에 충돌 컴포넌트와 메시 컴포넌트 추가

 : BaseItem 클래스는 모든 아이템(코인, 포션, 무기 등)에 공통으로 필요한 기능을 담는 부모 클래스이다.

- SceneComponent* Scene;
 : 액터(아이템)의 루트 컴포넌트로 사용한다.
- USphereComponent* Collision;
 : 플레이어가 범위 안에 들어오면 Overlap 이벤트를 발생시킬 충돌 컴포넌트이다.
- UStaticMeshComponent* StaticMesh;
 : 아이템이 월드에 표시될 때, 시각적인 모습을 담당한다.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "ItemInterface.h"
#include "BaseItem.generated.h"

class USphereComponent;

UCLASS()
class SPARTAPROJECT_API ABaseItem : public AActor, public IItemInterface
{
    GENERATED_BODY()

public:
    ABaseItem();

protected:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
    FName ItemType;
    // 루트 컴포넌트 (씬)
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Item|Component")
    USceneComponent* Scene;
    // 충돌 컴포넌트 (플레이어 진입 범위 감지용)
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Item|Component")
    USphereComponent* Collision;
    // 아이템 시각 표현용 스태틱 메시
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Item|Component")
    UStaticMeshComponent* StaticMesh;

    virtual void OnItemOverlap(
        UPrimitiveComponent* OverlappedComp,
        AActor* OtherActor,
        UPrimitiveComponent* OtherComp,
        int32 OtherBodyIndex,
        bool bFromSweep,
        const FHitResult& SweepResult) override;
    virtual void OnItemEndOverlap(
        UPrimitiveComponent* OverlappedComp,
        AActor* OtherActor,
        UPrimitiveComponent* OtherComp,
        int32 OtherBodyIndex) override;
    virtual void ActivateItem(AActor* Activator) override;
    virtual FName GetItemType() const override;

    void DestroyItem();
};

BaseItem.h

- UPrimitiveComponent* OverlapComp
 뜻 : "나의 어떤 부분에 닿았나?"
 설명 : 아이템 전체가 아니라, 아이템을 둘러싸고 있는 '보이지 않는 센서 박스' 중 어느 박스에 닿았는지 알려준다.
- AActor* OtherActor (가장 많이 쓴다)
 뜻 : "나한테 닿은 그 녀석은 누구인가?"
 설명 : 나랑 부딪힌 상대방이다.
           주인공 캐릭터인지, 아니면 굴러가던 돌맹이인지 확인할 때 쓴다 (예; 주인공이 맞으면 아이템을 주고, 몬스터면 무시)
- UPrimitiveComponent* OtherComp
 뜻 : "상대방의 어느 부분에 닿았나?"
 설명 : 부딪힌 상대방의 몸통에 닿았는지, 아니면 상대방이 휘두른 칼 끝에 닿았는지 알려준다.
- int32 OtherBodyIndex
 뜻 : (상대방의 뼈대 번호)
 설명 : 몬스터의 머리통인지 팔뚝인지 아주 정밀하게 따질 때 쓴다.
- bool bFromSweep
 뜻 : "물리적으로 움직이다가 부딪혔는가?" (true / false)
- const FHitResult& SweepResult
 뜻 : "부딪힌 정확한 위치 정보"
 설명 : 총알이 벽에 맞았을 때, 벽의 어느 좌표에 딱 맞았는지 알아내서 그 자리에 불꽃 효과(파티클)을 터뜨릴 때 유용하다.

팁 : 닿았을 때(OnItemOverlap) 과 멀어질 때(OnItemEndOverlap) 정도만 이해해도 된다.

#include "BaseItem.h"
#include "Components/SphereComponent.h"

ABaseItem::ABaseItem()
{
    PrimaryActorTick.bCanEverTick = false;
    
    // 루트 컴포넌트 생성 및 설정
    Scene = CreateDefaultSubobject<USceneComponent>(TEXT("Scene"));
    SetRootComponent(Scene);

    // 충돌 컴포넌트 생성 및 설정
    Collision = CreateDefaultSubobject<USphereComponent>(TEXT("Collision"));
    // 겹침만 감지하는 프로파일 설정
    Collision->SetCollisionProfileName(TEXT("OverlapAllDynamic"));
    // 루트 컴포넌트로 설정
    Collision->SetupAttachment(Scene);
    
    // 스태틱 메시 컴포넌트 생성 및 설정
    StaticMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StaticMesh"));
    StaticMesh->SetupAttachment(Collision);
    // 메시가 불필요하게 충돌을 막지 않도록 하기 위해, 별도로 NoCollision 등으로 설정할 수 있음.

    // Overlap 이벤트 바인딩
    Collision->OnComponentBeginOverlap.AddDynamic(this, &ABaseItem::OnItemOverlap);
    Collision->OnComponentEndOverlap.AddDynamic(this, &ABaseItem::OnItemEndOverlap);
}

void ABaseItem::OnItemOverlap(
    UPrimitiveComponent* OverlappedComp,
    AActor* OtherActor, 
    UPrimitiveComponent* OtherComp, 
    int32 OtherBodyIndex, 
    bool bFromSweep, 
    const FHitResult& SweepResult)
{
     // OtherActor가 플레이어인지 확인 ("Player" 태그 활용)
     if (OtherActor && OtherActor->ActorHasTag("Player"))
    {
        GEngine->AddOnScreenDebugMessage(-1, 2.0f, FColor::Green, FString::Printf(TEXT("Overlap!!!")));
        // 아이템 사용 (획득) 로직 호출
        ActivateItem(OtherActor);
    }
}

void ABaseItem::OnItemEndOverlap(
    UPrimitiveComponent* OverlappedComp, 
    AActor* OtherActor, 
    UPrimitiveComponent* OtherComp, 
    int32 OtherBodyIndex)
{
}

void ABaseItem::ActivateItem(AActor* Activator)
{
     GEngine->AddOnScreenDebugMessage(-1, 2.0f, FColor::Green, FString::Printf(TEXT("Overlap!!"));
}

FName ABaseItem::GetItemType() const
{
    return ItemType;
}

void ABaseItem::DestroyItem()
{
    Destroy();
}

BaseItem.cpp

- CollisionComponent->SetCollisionProfileName(TEXT("OverlapAllDynamic"));
 : SphereComponent 가 다른 액터와 겹칠 때만 Overlap 이벤트를 발생시키도록 설정한다.
   물리적인 충돌(Hit)은 발생하지 않는다.
- OnComponentBeginOverlap.AddDynamic(this, &ABaseItem::OnItemOverlap);
 : 플레이어가 범위 안에 들어올 때 자동으로 OnItemOverlap을 호출한다.
- GEngine->AddOnScreenDebugMessage(-1, 2.0f, FColor::Green, FString::printf(TEXT("Overlap"));
 : 코드가 잘 작동하였는지 테스트용 글씨를 화면에 띄운다.

 

 3) ItemInterface 인터페이스 함수 시그니처 수정

#pragma once

#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "ItemInterface.generated.h"

UINTERFACE(MinimalAPI)
class UItemInterface : public UInterface
{
    GENERATED_BODY()
};

class SPARTAPROJECT_API IItemInterface
{
    GENERATED_BODY()

public:
    UFUNCTION()
    virtual void OnItemOverlap(
        UPrimitiveComponent* OverlappedComp,
        AActor* OtherActor,
        UPrimitiveComponent* OtherComp,
        int32 OtherBodyIndex,
        bool bFromSweep,
        const FHitResult& SweepResult) = 0;
    UFUNCTION()
    virtual void OnItemEndOverlap(
        UPrimitiveComponent* OverlappedComp,
        AActor* OtherActor,
        UPrimitiveComponent* OtherComp,
        int32 OtherBodyIndex) = 0;
    virtual void ActivateItem(AActor* Activator) = 0;
    virtual FName GetItemType() const = 0;
};

ItemInterface.h

 

 - 아이템들이 모두 가져야 할 최소한의 동작을 위한 인터페이스에 Overlap 이벤트 처리에 바인딩할 함수를 수정하도록 한다.

 - OnItemOverlap 과 OnItemEndOverlap 매개변수를 수정한다.

 

2. 아이템 Blueprint 생성 및 콜리전/메시 설정하기

 1) 아이템 블루프린트 생성 및 Static Mesh 설정

- C++ 클래스 기반 블루프린트 생성
 : C++로 작성한 클래스들을 (BigCoinItem, SmallCoinItem, MineItem, HealingItem 4개만 해당) 언리얼 에디터에서 우클릭 -> Create Blueprint Class Based on... 을 선택해 Blueprint를 생성한다.
- Static Mesh 및 머티리얼 설정
 : Components 패널에서 StaticMesh (UStaticMeshComponent)를 선택
   Details 패널에서 Static Mesh를 원하는 에셋으로 설정
   메시를 선택한 상태에서 Details 패널을 보면, Material 항목이 있다.
   원하는 머티리얼을 적용

 

 2) 콜리전 범위 (Sphere Radius) 조정

- Components 패널에서 SphereComponent를 선택
 : 기본적으로 ABaseItem 클래스 내에서 충돌 컴포넌트가 생성되어 있을 것이며, 이는 BP 상속 시 그대로 노출된다.
- Details 패널에서 크기 조정
 : Sphere Radius (또는 Box의 경우 Box Extent) 값을 변경하면 충돌 범위를 직관적으로 조절할 수 있다.
   범위를 키우거나 줄일 때, 바로 뷰포트 상에서 확인 가능하므로 적절한 크기로 설정한다.

 

 3) 아이템 액터의 콜리전 프리셋 설정

- 콜리전 컴포넌트 설정 확인
 : 생성한 BP를 더블클릭하여 열고, Components 패널에서 SphereComponent를 선택한다.
   Details 패널에서 Collision섹션을 찾는다.
   Collision Presets가 어떤 값으로 설정되어 있는지 확인한다.
   부모 클래스(ABaseItem)에서 OverlapDynamic으로 설정해두었다.
- 콜리전 프리셋 (Collison Preset)
 : 언리얼 엔진은 여러 가지 콜리전 프리셋을 제공한다.
   이 프리셋을 통해 어떤 액터 (또는 채널)와 충돌을 Block할지, Overlap할지, Ignore할지를 손쉽게 설정할 수 있다.
   - 주요 프리셋 옵션
   1. NoCollison
     : 충돌을 전혀 감지하지 않으므로, Overlap 또는 Hit 이벤트가 발생하지 않는다.
       사용 예시 : 단순 배경 오브젝트 (하늘, 장식용 액터 등)
   2. BlockAll
     : 모든 객체와 충돌하여 막게 된다. 물리적으로 충돌하지만, Overlap 이벤트는 발생하지 않는다.
       사용 예시 : 벽, 바닥 같은 고정된 장치
   3. OverlapAll
     : 모든 Overlap 이벤트를 발생시킨다.
       사용 예시 : 트리거 존, 감지 센서, 투명한 오브젝트
   4. BlockAllDynamic
     : 움직이는 (Dyanmic) 객체만 충돌을 막는다. 고정된 객체와는 충돌하지 않는다.
       사용 예시 : 움직이는 플레이어나 물리 오브젝트와 상호작용하는 문, 벽 (고정된 환경 요소와는 무관하게 작동)
   5. OverlapAllDynamic
     : 움직이는 (Dynamic) 객체와 Overlap 이벤트를 발생시킨다.
       사용 예시 : 플레이어가 근처에 있는지 확인하는 아이템, 센서 (Overlap 이벤트가 필요하지만, 물리 충돌이 필요없는 경우)
   6. Pawn
     : 플레이어나 AI 처럼 Pawn 타입 객체를 대상으로 충돌을 감지하거나 막는다.
       사용 예시 : 플레이어 전용 문, AI 전용 센서
   7. Custom
     : 각 채널에 대해 충돌 응답 (Overlap, Block, Ignore)을 객체별로 세부적으로 설정할 수 있다.
- 물리 반응 여부 (Collision Enabled)
 : 충돌이 켜져있어도 물리적 반응이 없는 "Query Only" 인지, 물리적인 반응까지 하는 "Query and Physics" 인지 구분할 수 있다.
   - NoCollison : 충돌 비활성화
   - Query Only : Overlap, Hit 등 충돌 이벤트는 감지하지만, 물리적으로 튕기거나 밀리는 반응은 없다.
   - Physics Only : 물리 반응만 일어나고, 이벤트 (Overlap/Hit)는 발생하지 않는다.
   - Query and Physics : 충돌 이벤트 + 물리 반응 모두 활성화

 

 4) 캐릭터 태그 부여 및 콜리전 프리셋 설정

- 플레이어 클래스에 "Player" 태그 부여
 : Details 패널에서 플레이어 캐릭터를 선택하고, Actor 섹션의 Tags 항목에 "Player"를 추가한다.
   C++ 코드에서 OherActor->ActorHasTag("Player")를 통해 플레이어인지 간단히 판별할 수 있다.
- 플레이어 클래스 콜리전 채널 확인
 : BP_SpartaCharacter의 Capsule Component를 선택하고, Details 패널의 Collision 섹션을 살펴본다.
   Collision Presets가 Pawn으로 설정되어 있으며, 이는 "OverlapAllDynamic" 와 대체로 호환되어 Overlap 이벤트를 발생시킨다.
   만약 Overlap 이벤트가 작동하지 않는다면, Project Settings -> Collision 탭에서 Pawn 채널과 OverlapAllDynamic 채널의 상호작용을 재확인하거나 수정해야 한다.

 

3. 아이템 클래스 충돌 처리 구현하기

 : 아이템 클래스에서 실제로 Overlap 이벤트가 발생했을 때 어떤 로직을 수행할지 살펴본다.

   예를 들어 코인 아이템이라면 점수를 주고, 힐링 아이템이라면 체력을 회복시키며, 지뢰 아이템이라면 폭발 타이머를 돌려서 데미지를 주는 등의 동작을 구현할 수 있다.

 

 1) 코인 아이템 공통 부모 클래스 충돌 처리

 : CoinItem은 "코인 아이템이 가져야 할 공통 기능(점수)" 을 정의하고, 실제 점수 획득은 ActiveItem 함수에서 처리한다.

#pragma once

#include "CoreMinimal.h"
#include "BaseItem.h"
#include "CoinItem.generated.h"

UCLASS()
class SPARTAPROJECT_API ACoinItem : public ABaseItem
{
    GENERATED_BODY()

public:
    ACoinItem();

protected:
    // 코인 획득 시 플레이어에게 줄 점수
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item")
    int32 PointValue;

    // 부모 클래스에서 상속받은 ActivateItem 함수를 오버라이드
    virtual void ActivateItem(AActor* Activator) override;
};

CoinItem.h

#include "CoinItem.h"

ACoinItem::ACoinItem()
{
    // 점수 기본값을 0으로 설정
    PointValue = 0;
    ItemType = "DefaultCoin";
}

void ACoinItem::ActivateItem(AActor* Activator)
{
    // 플레이어 태그 확인
    if (Activator && Activator->ActorHasTag("Player"))
    {
        // 점수 획득 디버그 메시지
        GEngine->AddOnScreenDebugMessage(-1, 2.0f, FColor::Green, FString::Printf
(TEXT("Player gained %d points!"), PointValue));
        
        // 부모 클래스 (BaseItem)에 정의된 아이템 파괴 함수 호출
        DestroyItem();
    }
}

CoinItem.cpp

- PointValue
 :  Blueprint에서도 값을 바꿀 수 있으므로, 스몰 코인은 10점, 빅 코인은 50점처럼 다양한 코인을 쉽게 파생시킬 수 있다.
- ActivateItem
 : 디버그 목적으로 GEngine->AddOnScreenDebugMessage를 사용했다.
   이후 플레이어의 점수 변수를 증가시키는 로직을 구현할 예정

 

 2) 빅 코인 아이템 충돌 처리

 : "빅 코인" 클래스는 CoinItem을 상속받아 점수만 50으로 설정해 준다.

#include "BigCoinItem.h"

ABigCoinItem::ABigCoinItem()
{
    // 상위 CoinItem의 PointValue를 50으로 덮어쓰기
    PointValue = 50;
    ItemType = "BigCoin";
}

void ABigCoinItem::ActivateItem(AActor* Activator)
{
    // 부모의 기본 점수 획득 로직 사용
    Super::ActivateItem(Activator);

    // 빅 코인만의 추가 동작(이펙트, 사운드 재생 등)을 여기서 추가할 수 있음
}

BigCoinItem.cpp

 

 

 3) 스몰 코인 아이템 충돌 처리

 : "스몰 코인" 클래스도 CoinItem을 상속받아 점수를 10으로 지정한다.

#include "SmallCoinItem.h"

ASmallCoinItem::ASmallCoinItem()
{
    PointValue = 10;
    ItemType = "SmallCoin";
}

void ASmallCoinItem::ActivateItem(AActor* Activator)
{
    // 부모의 기본 점수 획득 로직 사용
    Super::ActivateItem(Activator);

    // 스몰 코인만의 별도 동작은 여기에 추가
}

SmallCoinItem.cpp

 

4) 힐링 아이템 충돌 처리

#pragma once

#include "CoreMinimal.h"
#include "BaseItem.h"
#include "HealingItem.generated.h"

UCLASS()
class SPARTAPROJECT_API AHealingItem : public ABaseItem
{
    GENERATED_BODY()

public
    AHealingItem();

protected:
    // 회복량
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Healing")
    int32 HealAmount;

    virtual void ActivateItem(AActor* Activator) override;
};

HealingItem.h

#include "HealingItem.h"

AHealingItem::AHealingItem()
{
    HealAmount = 20.0f;
    ItemType = "Healing";
}

void AHealingItem::ActivateItem(AActor* Activator)
{
    if (Activator && Activator->ActorHasTag("Player"))
    {
        // 회복 디버그 메시지
        GEngine->AddOnScreenDebugMessage(-1, 2.0f, FColor::Green, FString::Printf
(TEXT("Player gained %d HP!"), HealAmount));
        
        DestroyItem();
    }
}

HealingItem.cpp

 

 - 이후 Activator가 캐릭터라는 전제하에, 플레이어의 체력 변수 혹은 함수를 호출해 직접 체력 회복을 처리하는 구현을 해야한다.

   (예: PlayerCharacter->Heal(HealAmount))

 

 5) 지뢰 아이템 충돌 처리

 : 이번에는 플레이어가 지뢰 범위에 들어오면 타이머를 시작하고, 일정 시간이 지난 후 폭발 범위 내 액터에게 데미지를 주는 지뢰 아이템이다.

1. 플레이어가 지뢰 발동 범위에 들어가면 지뢰가 활성화되고 타이머가 시작된다.
2. 발동 후 5초가 지나야 폭발하며, 폭발 범위 내에 있는 액터를 확인한다.
3. 폭발 범위 내에 있는 액터 중 발동 범위에 남아있던 액터에게만 데미지를 입힌다.
4. 지뢰는 폭발 후 사라진다.

#pragma once

#include "CoreMinimal.h"
#include "BaseItem.h"
#include "MineItem.generated.h"

UCLASS()
class SPARTAPROJECT_API AMineItem : public ABaseItem
{
    GENERATED_BODY()

public:
    AMineItem();

protected:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Item|Component")
    USphereComponent* ExplosionCollision;

    // 폭발까지 걸리는 시간 (5초)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mine")
    float ExplosionDelay;
    // 폭발 범위
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mine")
    float ExplosionRadius;
    // 폭발 데미지
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mine")
    int ExplosionDamage;
    
    // 지뢰 발동 여부
    FTimerHandle ExplosionTimerHandle;

    virtual void ActivateItem(AActor* Activator) override;

    void Explode();
};

MineItem.h

- bIsActivated
 : 이미 지뢰가 발동되었는지 여부를 체크하기 위한 불리언 변수이다.
- ActivateItem
 : 발동 이후 타이머를 설정하고, 폭발 함수를 스케줄링한다.
- Explode
 : 타이머가 만료되었을 때 실제 폭발 처리를 담당한다.

#include "MineItem.h"
#include "Components/SphereComponent.h"

AMineItem::AMineItem()
{
    ExplosionDelay = 5.0f;
    ExplosionRadius = 300.0f;
    ExplosionDamage = 30.0f;
    ItemType = "Mine";
    
    ExplosionCollision = CreateDefaultSubobject<USphereComponent>(TEXT("ExplosionCollision"));
    ExplosionCollision->InitSphereRadius(ExplosionRadius);
    ExplosionCollision->SetCollisionProfileName(TEXT("OverlapAllDynamic"));
    ExplosionCollision->SetupAttachment(Scene);
}

void AMineItem::ActivateItem(AActor* Activator)
{
    // 5초 후 폭발 실행
    GetWorld()->GetTimerManager().SetTimer
(ExplosionTimerHandle, this, &AMineItem::Explode, ExplosionDelay);
}

void AMineItem::Explode()
{
    TArray<AActor*> OverlappingActors;
    ExplosionCollision->GetOverlappingActors(OverlappingActors);

    for (AActor* Actor : OverlappingActors)
    {
        if (Actor && Actor->ActorHasTag("Player"))
        {
            GEngine->AddOnScreenDebugMessage
(-1, 2.0f, FColor::Red, FString::Printf(TEXT("Player damaged %d by MineItem"), ExplosionDamage));
        }
    }

    // 지뢰 제거
    DestroyItem();
}

MineItem.cpp

- ActivateItem
 : GetWorld()->GetTimerManager().SetTimer 를 사용해 5초 후 Explode() 가 자동 실행되도록 지연 호출(Delayed Call) 한다.
- Explode()
 : 폭발이 일어날 때 주변 액터를 검사해, 지뢰 범위(ExplosionRadius) 안에 있고 지뢰 콜리전 컴포넌트와 여전히 Overlap 상태인 플레이어에게 데미지를 주는 예시이다.
   폭발 처리 후 DestroyItem() 을 호출해 지뢰 아이템 자체를 제거한다.

 

4. 아이템 배치 및 충돌 체크하기

 1) 콜리전 비주얼 디버깅

 : 언리얼 에디터에서 Alt + C (기본 단축키)로 콜리전 디버그 모드를 켜면, Capsule Component 뿐 아니라 Sphere, Box 같은 다른 콜리전 영역도 시각적으로 확인할 수 있다.

   콜리전이 비정상적으로 설정 되어 있을 경우, 이 기능을 통해 빠르게 확인 가능하다.

 

 2) 아이템 레벨 배치 및 테스트

1. 레벨에 아이템 배치
 - 콘텐트 브라우저에서 만든 아이템 Blueprint를 레벨에 드래그 앤 드롭한다.
 - 아이템 액터를 선택한 뒤, Details에서 콜리전 범위나 메시 설정 등을 최종 점검할 수 있다.
2. 아이템 획득 테스트
 - 게임을 시작하고 플레이어 캐릭터를 아이템 근처로 이동한다.
 - 코인 아이템이라면 획득 관련 메시지가 뜨고 아이템이 사라지는지, 힐링 아이템이라면 체력 회복 디버그 메시지가 표시되는지, 지뢰라면 타이머 후 폭발 디버그 메시지가 잘 뜨는지 확인한다.