game.destroy()

[UE5] 캐릭터 메시에 물리 적용하기 (Control Physics 활용)

destroyer — Tue, 5 Nov 2024 10:29:19 +0900

적용 결과

Physic Control

Physics Control은 Unreal Engine 5에서 새롭게 도입된 기능으로, 플레이어의 스켈레탈 메시에 물리 효과를 적용할 수 있다. 이 기능은 애니메이션과 물리를 조화롭게 융합하여 자연스러운 물리적 현상을 연출하는 데 중점을 두고 있다. 특히, Physics Control은 캐릭터가 피격을 당하거나 충돌하는 상황에서 현실감 넘치는 물리 반응을 구현하는 강력한 도구이다.

이 기능을 사용하면 애니메이션만으로는 연출하기 어려운 다양한 물리적 반응을 시뮬레이션할 수 있어, 플레이어가 공격을 받았을 때 캐릭터의 움직임이 실제 세계에서의 반응처럼 자연스럽고 다이내믹하게 보이도록 만든다.

Physic Control 플러그인 설치

일단 플레이어에 추가해보기

Build.cs

PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "EnhancedInput", "AIModule", "NavigationSystem", "UMG",
    "Niagara", "CableComponent", "MotionWarping", "PhysicsControl"});

M4_BasePlayer

// M4_BasePlayer.h
    UPROPERTY(EditAnywhere, BlueprintReadWrite,Category = "Components")
    class UPhysicsControlComponent* PhysicsControlComp;

// M4_BasePlayer.cpp
AM4_BasePlayer::AM4_BasePlayer()
{
     // 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;

    // ...

    PhysicsControlComp = CreateDefaultSubobject<UPhysicsControlComponent>(TEXT("PhysicsControlComp"));
    PhysicsControlComp->SetupAttachment(RootComponent);
}

Build.cs에 내용을 Physics Control을 추가하고, 플레이어에 UPhysicsComponent를 생성해준다.

Physics Control Component

블루프린트로 본 Controls Physics Component

이 Detail 창에서는 주요 설정을 바로 조정할 수 있는 옵션이 거의 없다. Physics Control Profile Asset을 설정하거나, 런타임 중에 직접 노드를 활용하거나 코드를 작성해 Physics Control을 생성하는 방식으로 사용해야 한다.

또한, 이 창에서는 디버그 시각화, 텔레포트 거리 임계값, 시각화 스케일과 같은 몇 가지 디버그 관련 옵션을 설정할 수 있다. 디버그 시각화를 활성화하면 물리 제어의 효과를 시각적으로 확인할 수 있어, 복잡한 물리 동작을 조정할 때 유용하다.

Physics Control Profile Asset

Physics Control Profile Asset은 물리 제어에 필요한 사전 설정을 담은 에셋으로, 이를 활용하면 일관성 있는 물리 제어를 손쉽게 적용할 수 있다. 이 에셋을 활용하면 캐릭터의 관절별로 필요한 물리적 제어를 설정할 수 있다. Limb Setup Data나 Modifier와 같은 세부 항목을 통해 각 부위별 물리 반응이나 물리 제어 강도를 조절할 수 있어, 더욱 세밀하고 정교한 제어가 가능하다.

Physics Control Profile Asset Base 만들기

LimbSetupData 설정

LimbSetupData에 엘리먼트를 추가하고, Limb 이름과 그에 매칭되는 Bone 이름을 설정해준다.

Include Parent Bone: 부모 뼈를 제어 설정에 추가
Create World Space Controls: 월드 스페이스에서 동작하는 컨트롤 생성
Create Parent Space Controls: 부모의 공간에서 동작하는 컨트롤 생성
Create Body Modifiers: 캐릭터의 신체 구조에 대한 추가적인 수정이나 제어 옵션 제공

팔, 머리, 다리, 허리까지 LimbData를 세팅

기본 World, Parent Space Control Data 비활성화

이 에셋은 Base Asset으로, 추후 만들 Player용 에셋에서 활성화 시켜주기 위해 부모 단에서는 비활성화 시켜주었다.

Modifier Set

물리를 적용할 부위를 그룹으로 모을 수 있게 설정하는 부분이다.

Kinematic Profile 생성

기본적으로 물리를 적용받지 않고 애니메이션으로 동작할 Kinematic Profile을 만들었다.

Physics Control Profile Asset Player 만들기

부모를 Base Asset으로 설정

새로운 프로필을 생성한다. BouncyWalk으로, 컨텐츠 예제의 BouncyWalk의 설정을 가져와 적용시켜주었다.

또한 Linear Strength를 2로 설정하여 특정 방향으로 힘을 받을 때 반발력을 약간 높여주고, Angular Strength는 1로 설정하여 회전하는 힘에는 반발력을 기본 수준으로 주도록 했다.

BouncyWalk 프로파일 주요 매개 변수 설명

매개 변수설명

Linear Strength	선형 힘의 강도 설정. 높을 수록 애니메이션에 더 중점
Angular Strength	회전에 적용되는 힘의 강도를 설정. 값이 높을수록 애니메이션에 더 중점.
Custom Control Point	제어 지점을 커스텀 위치로 설정. (X, Y, Z 좌표)로 지정
Enabled	이 설정을 활성화할지 여부를 선택. 활성화 시 체크
Use Custom Control Point	커스텀 제어 지점을 사용할지 선택. 선택하지 않으면 기본 제어 지점이 사용됩니다.
Use Skeletal Animation	스켈레탈 애니메이션을 사용할지 여부를 선택. 활성화 시 체크
Disable Collision	충돌을 비활성화할지 여부를 선택. 체크 시 충돌 무시
Only Control Child Object	자식 객체만 제어할지 여부를 선택. 체크 시 부모 객체에 영향을 주지 않음.

Modifier Updates 설정

모든 Limb에 대해 Simulated를, Feet Set에 대해서는 Kinematic으로 설정해 두도록 Modifier를 추가해주었다.

플레이어에 적용해보기

이렇게 다양한 프로필을 설정해두고, 특정 시점마다 Profile을 변경시켜 Control Physics적용을 변화시킬 수 있다. 여기서는 블루프린트를 이용해 간단하게 키 입력으로 테스트해 보겠다.

Physics Control Comp에 피직스 컨트롤 프로필 에셋을 설정

BeginPlay에서 PhysicControl을 Control Profile Asset을 이용하여 생성하는 노드와, ControlProfile을 BouncyWalk로 설정하는 노드를 추가.

T Key와 U Key에 각각 Kinematic과 BouncyWalk로 피직스 컨트롤 프로필을 변경시켜주는 노드를 연결해 둔다.

BouncyWalk상태와 Kinematic 상태 비교

각 상태가 충돌에 반응하는 방식의 차이를 선명하게 보여준다.

BouncyWalk 상태에서는 충돌이 발생할 때마다 캐릭터의 메쉬가 유연하게 흔들리며 생동감 넘치는 반응을 연출한다.

반면, Kinematic 상태에서는 캐릭터 메쉬가 단단히 고정된 듯 움직인다. 충돌 시 캐릭터는 외부 힘에 의해 물리적 위치가 밀리긴 하지만, 자체적인 흔들림이나 탄성 있는 움직임은 없다.

C++ 코드로 사용

// M4_BasePlayer.h

// Physics Control Profile 이름 저장
FName Bounce = TEXT("BouncyWalk");
FName Kinematic = TEXT("Kinematic");
FName Soft = TEXT("SoftWalk");

// M4_BasePlayer.cpp
void AM4_BasePlayer::BeginPlay()
{
    Super::BeginPlay();

    // ...

    if (PhysicsControlComp)
    {
        // Control 생성
        PhysicsControlComp->CreateControlsAndBodyModifiersFromControlProfileAsset(GetMesh(),nullptr, FName());
        // Control 프로필 설정 (기본을 키네마틱으로)
        PhysicsControlComp->InvokeControlProfile(Kinematic);
    }

}

위 코드에서 기본 설정으로 캐릭터는 Kinematic 상태로 시작하여, 움직임이 고정된 상태에서 플레이를 진행하게 된다. 그러나 전투 중 피격, 추락 등 특별한 상황이 발생하면 프로필을 BouncyWalk 또는 SoftWalk로 전환하여 각기 다른 물리 효과를 적용할 수 있다.

예를 들면, 피격 시에는 BouncyWalk 프로필을 활성화하여 충격에 의해 몸이 크게 흔들리도록 하여 긴장감 넘치는 전투 느낌을 살리고, 추락 시에는 SoftWalk 상태로 부드러운 물리 반응을 추가하여 착지의 충격을 표현할 수 있다.

참고 자료

Physic Control을 사용하는 예제 영상
UE5 샘플 컨텐츠들을 모아놓은 프로젝트 컨텐츠 예제

컨텐츠 예제 다운로드 페이지 ( Fab )

[UE5] 인벤토리 시스템 - 인벤토리 UI

shinhongk — Mon, 4 Nov 2024 18:26:07 +0900

프로젝트 개요

여러 명이 하나의 스포츠 영상을 시청하면서 특정 대상(스포츠 팀 / 선수)을 응원하는 플랫폼을 제공하는 메타버스 컨텐츠를 제작하는 프로젝트

인벤토리의 필요성

스포츠 경기를 관람할 때 다이나믹한 응원을 위해 폭죽을 터트리고 응원봉을 흔들듯 여러 아이템이 있으면 영상을 시청하는데 재미 요소를 더할 수 있을 것이라 판단했고, 여러 아이템을 자신이 가진 포인트로 구매하고 구매한 아이템 소지하는 기능이 필요하다 판단하여 인벤토리를 구현하게 되었다.

구현 개요

인벤토리 UI는 플레이어가 갖고 있는 InventoryComponent를 참조해 InventoryComponent의 Invetory 배열이 변경될 때마다 UI를 갱신한다. 키보드 입력 I를 통해 인벤토리 UI를 팝업시킬 수 있다. 인벤토리 UI를 통해 아이템을 사용 및 장착하고 인벤토리에서 아이템을 버리는 기능을 사용할 수 있다. 간단한 Inventory이기도 하고 Drag& Drop이 필수 기능은 아니라 생각해 넣지 않았다.

인벤토리 UI 구현

인벤토리 UI

인벤토리에서 사용

아이템 구매

Widget 생성자 (NativeContruct)

void UInventoryWidget::NativeConstruct()
{
	if (!Btn_ThrowAway->OnClicked.IsBound())
	{
		Btn_ThrowAway->OnClicked.AddDynamic(this, &UInventoryWidget::ThrowAwaySelectedItem);
	}
	if (!Btn_Use->OnClicked.IsBound())
	{
		Btn_Use->OnClicked.AddDynamic(this, &UInventoryWidget::UseItem);
	}
	if (!Btn_CostumeCategory->OnClicked.IsBound())
	{
		Btn_CostumeCategory->OnClicked.AddDynamic(this, &UInventoryWidget::SelectCategory_Costume);
	}
	if (!Btn_ActiveCategory->OnClicked.IsBound())
	{
		Btn_ActiveCategory->OnClicked.AddDynamic(this, &UInventoryWidget::SelectCategory_Active);
	}
	if (!Btn_EmotionCategory->OnClicked.IsBound())
	{
		Btn_EmotionCategory->OnClicked.AddDynamic(this, &UInventoryWidget::SelectCategory_Emotion);
	}	
	if (!Btn_EmojiCategory->OnClicked.IsBound())
	{
		Btn_EmojiCategory->OnClicked.AddDynamic(this, &UInventoryWidget::SelectCategory_Emoji);
	}
	if (!Btn_SoundCategory->OnClicked.IsBound())
	{
		Btn_SoundCategory->OnClicked.AddDynamic(this, &UInventoryWidget::SelectCategory_Sound);
	}

	GI = Cast<UHG_GameInstance>(GetWorld()->GetGameInstance());
	SelectedCategory = WB_SlotList_Active;
}

※Constructor에서 AddDynamic으로 바인딩을 한 번 하고 다음에 또 바딩을 시도하면 오류 발생하므로 이벤트의 IsBound() 함수를 통해 이벤트가 바운딩 됐는지를 검사해야함. 충돌이 나거나 엔진이 터지진 않지만 UI에서의 기능들이 이상해진다.

인벤토리UI 초기화 함수 (InitInventoryUI())

void UInventoryWidget::InitInventoryUI()
{
	// 모든 WrapBox의 자식들을 없애준다. (해주지 않으면 아이템이 복사됨)
	WB_SlotList_Active->ClearChildren();
	WB_SlotList_Costume->ClearChildren();
	WB_SlotList_Emotion->ClearChildren();
	WB_SlotList_Emoji->ClearChildren();
	WB_SlotList_Sound->ClearChildren();
	// 선택 슬롯도 초기화 (UX 적으로 인벤토리를 껐다 켰을 때 선택된 슬롯도 없는 것이 맞다고 판단)
	SelectedSlot = nullptr;
	DIsplaySelectedItemInfo();
	// 현재 이 인벤토리 위젯이 어떤 Pawn 에게 소유 되었는지 검사
	if (this->GetOwningPlayer() != nullptr)
	{
		// 소유하고 있는 Pawn 이 있다면
		// 해당 Pawn 을 Player 로 Cast 한다.
		auto* OwningPlayer = Cast<AHG_Player>(this->GetOwningPlayer()->GetPawn());
		if (OwningPlayer)
		{
			// Cast 에 성공했다면
			// 해당 Player 가 가진 Inventory 의 모든 요소를 접근 
			for (auto slot : OwningPlayer->InventoryComp->Inventory)
			{
				// 각 슬롯(요소)별로 위젯을 만듦
				UHG_SlotWidget* SlotWidget = CreateWidget<UHG_SlotWidget>(this, SlotWidgetFactory);
				if (SlotWidget)
				{
					// 만드는데 성공했다면
					
					// 슬롯 위젯을 현재 접근 중인 인벤토리 슬롯의 데이터로 초기화해준다.
					SlotWidget->InitSlot(slot);
					SlotWidget->SetItemIcon();

					// 슬롯 위젯의 주인을 설정해준다. (인벤토리 UI에서 상대적인 자기 자신에 대한 정보를 알아야하기 때문)
					SlotWidget->SetOwner(this);

					// 현재 접근하고 있는 슬롯의 카테고리에 맞는 WrapBox에 넣어주기 위한 EItemCategory 검사
					if (slot.ItemInfo.ItemCategory == EItemCategory::Category_Active)
					{
						WB_SlotList_Active->AddChildToWrapBox(SlotWidget);
					}
					else if (slot.ItemInfo.ItemCategory == EItemCategory::Category_Emotion)
					{
						WB_SlotList_Emotion->AddChildToWrapBox(SlotWidget);
					}
					else if (slot.ItemInfo.ItemCategory == EItemCategory::Category_Emoji)
					{
						WB_SlotList_Emoji->AddChildToWrapBox(SlotWidget);
					}
					else if (slot.ItemInfo.ItemCategory == EItemCategory::Category_Sound)
					{
						WB_SlotList_Sound->AddChildToWrapBox(SlotWidget);
					}
					else
					{
						WB_SlotList_Costume->AddChildToWrapBox(SlotWidget);
						CheckEquipitem();
 						for (auto EquipSlot : EquipList)
 						{
							// 갖고있는 ItemData의 ItemName으로 현재 생성한 SlotWidget가 EquipList에 요소로 존재했었는지 검사
 							if (EquipSlot->SlotInfo.ItemInfo.ItemName == SlotWidget->SlotInfo.ItemInfo.ItemName)
 							{
								// EquipList에 존재했었다면
								
								// 아이템이 현재 장착되었는지 보여주기 위한 표시
								// HitTestInvisible => 클릭 등의 입력을 비활성화 하는 옵션, 그냥 Visible로 하면 Slot에 있는 Button 의 입력을 Img_Equip 이 가져감
 								SlotWidget->Img_Equip->SetVisibility(ESlateVisibility::HitTestInvisible);

								// EquipList에서 기존에 장착했던 아이템을 다시 생성한 SlotWidget로 갱신해줌
 								EquipList[EquipList.Find(EquipSlot)] = SlotWidget;
 							}
 						}
					}
				}
			}
		}
	}
	// 인벤토리를 팝업하자마자 보이는 WrapBox 는 Active 로 설정
	SelectedCategory = WB_SlotList_Active;
	WS_Category->SetActiveWidgetIndex(0);
}

아이템 버리기 (ThrowAwaySelectedItem())

// 아이템 버리기
void UInventoryWidget::ThrowAwaySelectedItem()
{
	if (SelectedSlot)
	{
		// 위젯의 주인 찾기  
		auto* Owner = Cast<AHG_Player>(this->GetOwningPlayer()->GetPawn());

		// 선택된 슬롯이 장착된 아이템 슬롯 리스트에 있는지 확인
		if (EquipList.Contains(SelectedSlot))
		{
			// 버튼의 텍스트를 장착하기로 바꿔줌
			TB_Use->SetText(FText::FromString(TEXT("장착하기")));

			// 선택된 슬롯의 장착 이미지를 보이지 않게 함
			SelectedSlot->Img_Equip->SetVisibility(ESlateVisibility::Hidden);
			
			// 장착된 아이템 슬롯 리스트에서 선택된 슬롯 제거
			EquipList.Remove(SelectedSlot);
			
			// 인벤토리 위젯의 주인이 장착하고 있는 아이템을 장착 해제
			Owner->UnequipItemToSocket(SelectedSlot->SlotInfo.ItemInfo.ItemName);
		}
		// 현재 선택된 Category WrapBox의 자식 개수를 가져옴
		int32 ChildCount = SelectedCategory->GetChildrenCount();
		// 자식의 수만큼 반복함
		for (int32 i = 0; i < ChildCount; i++)
		{
			// SelectedCategory 에서 i 번째 자식을  가져와서 UHG_SlotWidget 으로 Casting 
			UHG_SlotWidget* Child = Cast<UHG_SlotWidget>(SelectedCategory->GetChildAt(i));

			// 선택한 슬롯과 SelectedCategory의 i 번째 자식이 같은지 확인
			if (Child == SelectedSlot)
			{
				// 같다면

				// NullCheck
				if (Owner)
				{
					// Owner의 인벤토리에서 선택된 슬롯의 데이터와 같은 아이템을 제거
					Owner->InventoryComp->RemoveFromInventory(SelectedSlot->SlotInfo.ItemInfo, 1);
				}
				// 슬롯의 Quantity를 하나 줄임
				SelectedSlot->SlotInfo.Quantity--;

				// 슬롯의 Quantity가 0이 되면
				if (SelectedSlot->SlotInfo.Quantity == 0)
				{
					// 선택된 카테고리의 i번째 자식을 없애고
					SelectedCategory->RemoveChildAt(i);
					// SelectedSlot을 비워줌
					SelectedSlot = nullptr;
				}
				// 현재의 슬롯 정보를 갱신
				DIsplaySelectedItemInfo();

				break;
			}

		}
	}
}

아이템 사용하기 (UseItem)

// 아이템 사용하기
void UInventoryWidget::UseItem()
{
	// NullCheck
	if (SelectedSlot)
	{
		// NullCheck
		if (this->GetOwningPlayer() != nullptr)
		{
			// 위젯의 주인 찾기  
			auto* OwningPlayer = Cast<AHG_Player>(this->GetOwningPlayer()->GetPawn());
			// NullCheck
			if (nullptr != OwningPlayer)
			{
				// 선택된 슬롯이 무엇인지 확인
				if (SelectedCategory == WB_SlotList_Active)
				{
					// Active에서 아이템을 사용했다면
					
					// 아이템을 월드에 스폰 시키고 사용하는 AHG_Player의 SpawnItem 함수 사용
					OwningPlayer->SpawnItem(SelectedSlot->SlotInfo.ItemInfo);

					// 아이템 1개 감소
					ThrowAwaySelectedItem();
				}
				else if (SelectedCategory == WB_SlotList_Emoji || SelectedCategory == WB_SlotList_Sound)
				{
					// 이모티콘 혹은 효과음 아이템을 사용했다면

					// 아이템을 월드에 스폰 시키고 사용하는 AHG_Player의 SpawnItem 함수 사용
					OwningPlayer->SpawnItem(SelectedSlot->SlotInfo.ItemInfo);
				}
				else if (SelectedCategory == WB_SlotList_Costume)
				{
					// GameInstance의 EquipSlotIndexList에 내가 선택한 슬롯의 아이템의 인덱스가 포함되어 있는지 확인 ==> 장착한 아이템인지 확인
					if (GI->EquipSlotIndexList.Contains(SelectedSlot->MyIndex))
					{
						// 장착한 아이템이라면

						// 사용하는 버튼의 텍스트를 해제하기에서 장착하기로 변경
						TB_Use->SetText(FText::FromString(TEXT("장착하기")));

						// 선택한 슬롯의 장착 표시 이미지를 보이지 않게 함
						SelectedSlot->Img_Equip->SetVisibility(ESlateVisibility::Hidden);

						// EquipList에서 선택한 슬롯을 제거
						EquipList.Remove(SelectedSlot);

						// GameInstance의 EquipSlotIndexList에서 현재 슬롯의 인덱스 제거
						GI->EquipSlotIndexList.Remove(GetSlotIndexInWB(SelectedSlot));

						// 플레이어 아이템 장착 해제
						OwningPlayer->UnequipItemToSocket(SelectedSlot->SlotInfo.ItemInfo.ItemName);
					}
					else
					{
						// 장착하지 않았다면 

						// 사용하는 버튼의 텍스트를 장착하기에서 해제하기로 변경
						TB_Use->SetText(FText::FromString(TEXT("해제하기")));

						// 선택한 슬롯의 장착 표시 이미지를 보이게 함
						SelectedSlot->Img_Equip->SetVisibility(ESlateVisibility::HitTestInvisible);

						// EquipList에서 선택한 슬롯을 추가
						EquipList.Add(SelectedSlot);

						// GameInstance의 EquipSlotIndexList에서 현재 슬롯의 인덱스 추가
						GI->EquipSlotIndexList.Add(GetSlotIndexInWB(SelectedSlot));

						// 플레이어 아이템 장착
						OwningPlayer->EquipItemToSocket(SelectedSlot->SlotInfo.ItemInfo);
					}
				}
				else if(SelectedCategory == WB_SlotList_Emotion)
				{
					// 이모션 아이템을 사용했다면

					// 플레이어가 Montage를 실행하도록 함
					OwningPlayer->ServerRPC_Emotion(SelectedSlot->SlotInfo.ItemInfo.Montage);
				}
			}
		}
	}
}

※ 아이템을 사용하면 아이템이 소모되는 코드를 ThrowAwaySelectedItem() 함수를 사용하였는데 본인이 진행한 프로젝트에선 아이템을 인벤토리에서 버렸을 때 월드에 버려지지 않고 그냥 사라지는 방식으로 기획되었기 때문에 아이템을 버리는 로직을 그대로 사용하였지만 아이템을 버렸을 때 월드에 아이템이 스폰되어야 한다면 ThrowAwaySelectedItem()을 아이템을 사용하는 코드에 사용하는 것은 바람직하지 못함

GetSlotIndexInWB()

// 현재 선택한 슬롯이 부모에서 몇 번째 자식인지 반환받는 함수
int32 UInventoryWidget::GetSlotIndexInWB(UWidget* SlotWidget)
{
	if (!WB_SlotList_Costume || !SlotWidget) return -1;

	const TArray<UWidget*>& Slots = WB_SlotList_Costume->GetAllChildren();

	int32 Index = Slots.IndexOfByKey(SlotWidget);

	return Index;
}

CheckEquipitem()

// 레벨 이동간 장착 아이템에 대한 정보를 유지하기 위한 함수
void UInventoryWidget::CheckEquipitem()
{
	if (GI->EquipSlotIndexList.Num() <= 0) return;

	for (auto n : GI->EquipSlotIndexList)
	{
		UHG_SlotWidget* EquipSlot = Cast<UHG_SlotWidget>(WB_SlotList_Costume->GetChildAt(n));
		if (EquipSlot)
		{
			EquipSlot->Img_Equip->SetVisibility(ESlateVisibility::HitTestInvisible);
		}
	}
}

카테고리를 바꾸는 버튼이 클릭 됐을 때 실행되는 함수들

// Active 카테고리 버튼이 클릭 됐을 때 실행되는 함수
void UInventoryWidget::SelectCategory_Active()
{
	SelectedCategory = WB_SlotList_Active;
	WS_Category->SetActiveWidgetIndex(0);
	TB_Use->SetText(FText::FromString(TEXT("사용하기")));
}

// Costume 카테고리 버튼이 클릭 됐을 때 실행되는 함수
void UInventoryWidget::SelectCategory_Costume()
{
	SelectedCategory = WB_SlotList_Costume;
	WS_Category->SetActiveWidgetIndex(1);

	if (SelectedSlot != nullptr && EquipList.Contains(SelectedSlot))
	{
		TB_Use->SetText(FText::FromString(TEXT("해제하기")));
	}
	else
	{
		TB_Use->SetText(FText::FromString(TEXT("장착하기")));
	}
}

// Emotion 카테고리 버튼이 클릭 됐을 때 실행되는 함수
void UInventoryWidget::SelectCategory_Emotion()
{
	SelectedCategory = WB_SlotList_Emotion;
	WS_Category->SetActiveWidgetIndex(2);
	TB_Use->SetText(FText::FromString(TEXT("사용하기")));
}

// Emoji 카테고리 버튼이 클릭 됐을 때 실행되는 함수
void UInventoryWidget::SelectCategory_Emoji()
{
	SelectedCategory = WB_SlotList_Emoji;
	WS_Category->SetActiveWidgetIndex(3);
	TB_Use->SetText(FText::FromString(TEXT("사용하기")));
}

// Sound 카테고리 버튼이 클릭 됐을 때 실행되는 함수
void UInventoryWidget::SelectCategory_Sound()
{
	SelectedCategory = WB_SlotList_Sound;
	WS_Category->SetActiveWidgetIndex(4);
	TB_Use->SetText(FText::FromString(TEXT("사용하기")));
}

SlotWidget이 클릭되었을 때 선택된 Slot의 아이템 정보를 표시하는 함수

void UInventoryWidget::DisplaySelectedItemInfo()
{	
	// 선택된 슬롯이 있는지 없는지 검사
	if (SelectedSlot)
	{
		// 있다면 선택된 슬롯의 정보로 UI를 갱신
		Img_SelectedItem->SetBrushFromTexture(SelectedSlot->SlotInfo.ItemInfo.ItemIcon);
		TB_ItemName->SetText(FText::FromString(SelectedSlot->SlotInfo.ItemInfo.ItemName));
		TB_Price->SetText(FText::AsNumber((SelectedSlot->SlotInfo.ItemInfo.ItemPrice)));
		TB_Quantity->SetText(FText::AsNumber(SelectedSlot->SlotInfo.Quantity));   
	}
	else
	{
		// 없다면 아무것도 표시하지 않음
		Img_SelectedItem->SetBrushFromMaterial(DefaultImage);
		TB_ItemName->SetText(FText::FromString(TEXT("")));
		TB_Price->SetText(FText::FromString(TEXT("")));
		TB_Quantity->SetText(FText::FromString(TEXT("")));
	}
}

[UE5] 인벤토리 시스템 - 인벤토리 기본 구조

shinhongk — Fri, 1 Nov 2024 20:57:26 +0900

프로젝트 개요

여러 명이 하나의 스포츠 영상을 시청하면서 특정 대상(스포츠 팀 / 선수)을 응원하는 플랫폼을 제공하는 메타버스 컨텐츠를 제작하는 프로젝트

인벤토리의 필요성

스포츠 경기를 관람할 때 다이나믹한 응원을 위해 폭죽을 터트리고 응원봉을 흔들듯 여러 아이템이 있으면 영상을 시청하는데 재미 요소를 더할 수 있을 것이라 판단했고, 여러 아이템을 자신이 가진 포인트로 구매하고 구매한 아이템을 관리 기능이 필요하다 판단하여 인벤토리를 구현하게 되었다.

구현 개요

인벤토리는 배열로 구현하고자 하였고 하나의 인벤토리의 슬롯에 대한 구조체와 아이템의 정보에 대한 구조체를 만들고

아이템 정보를 하나의 Row로 하는 DataTable을 만들어 구매, 사용, 획득 간에 DataTable을 참조하여 실제 아이템 오브젝트를 인벤토리에 넣는 것이 아닌 아이템에 대한 정보를 인벤토리에 담으려 함.

인벤토리 구조

SlotStruct 구조

SlotStruct는 구조체로 인벤토리 한 칸에 대한 정보를 의미한다.

SlotStruct는 ItemData라는 구조체와 SlotQuantity라는 int32 자료형의 변수를 멤버로 갖고 있다.

ItemData는 아이템이 가져야 할 기본적인 데이터를 멤버로 갖는다.

ItemData에 == 연산자를 다중정의한 이유는 두 개의 아이템이 같은 아이템인지 비교할 때, 아이템 데이터를 비교하여 판단하기 위함이다.

USTRUCT(BlueprintType)
struct FItemData : public FTableRowBase
{
	GENERATED_USTRUCT_BODY()
public:
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	FString ItemName;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	UTexture2D* ItemIcon = nullptr;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	int32 ItemPrice;

	UPROPERTY(EditDefaultsOnly)
	TSubclassOf<AHG_ItemBase> ItemClass;

	UPROPERTY(EditDefaultsOnly)
	EItemCategory ItemCategory;

	bool operator==(const FItemData& Other) const
	{
		return ItemName == Other.ItemName;
	}
};

USTRUCT(Atomic, BlueprintType)
struct FSlotStruct
{
	GENERATED_BODY()
public:

	UPROPERTY(EditAnywhere)
	int32 Quantity = 0;
    
	UPROPERTY(EditDefaultsOnly)
	FItemData ItemInfo;
};

인벤토리는 SlotStruct라는 구조체를 하나의 원소로 갖는 1차원 배열로 선언

Unreal Editor에서 ItemData를 하나의 행으로 하는 DataTable 생성

※ Unreal Editor에서 DataTable을 만들 때, C++로 구현한 구조체를 DataTable의 RowData로 설정하려면 FTableRowBase를 상속받아야 함.

인벤토리 기능 함수

- 인벤토리 관련 기능은 Player 클래스에서 분리하고 PlayerInventoryComponent라는 클래스에서 따로 관리하고 Player가 PlayerInventoryComponent를 컴포넌트로 갖도록 하는 구조

#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "SlotStruct.h"
#include "HG_PlayerInventoryComponent.generated.h"

UCLASS(ClassGroup = (Custom), meta = (BlueprintSpawnableComponent))
class METACHEERINGROOM_API UHG_PlayerInventoryComponent : public UActorComponent
{
	GENERATED_BODY()

public:
	// Sets default values for this component's properties
	UHG_PlayerInventoryComponent();

protected:
	// Called when the game starts
	virtual void BeginPlay() override;

public:
	// Called every frame
	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

	// 인벤토리의 최대 크기
	UPROPERTY(EditDefaultsOnly)
	int32 InventorySize;
	
    	// FSlotStruct을 요소로 갖는 배열 (실제 인벤토리)
	TArray<FSlotStruct> Inventory;

	// 인벤토리에 아이템 추가
	// Parameter
	// Item : 인벤토리에 추가할 아이템의 정보(FItemData 구조체)
	// Quantity : 인벤토리에 넣을 아이템 개수
	void AddtoInventory(FItemData Item, int32 Quantity);

	//  인벤토리에 아이템이 존재하는지 존재한다면 그 아이템의 인덱스를 반환
	// Parameter 
	// ItemName : 검사하고싶은 아이템 이름
	// Return
	// int32, 찾은 아이템의 인덱스, 없으면 -1 반환
	int32 FindSlot(FString ItemName);

	// 인벤토리에서 아이템 제거
	// Parameter
	// Item : 인벤토리에 제거할 아이템의 정보(FItemData 구조체)
	// Quantity : 인벤토리에서 제거할 아이템 개수
	void RemoveFromInventory(FItemData Item, int32 Quantity);
    
    	// 아이템 정보를 담는 데이터 테이블
	UPROPERTY(EditDefaultsOnly)
	class UDataTable* ItemDataTable;
	
    	// 컴포넌트를 갖고있는 플레이어의 정보
	class AHG_Player* CompOwner;
};

void AddtoInventory(FItemData Item, int32 Quantity)

void UHG_PlayerInventoryComponent::AddtoInventory(FItemData Item, int32 Quantity)
{
	// 만약 인벤토리의 크기가 최대 크기가 넘는지 확인
	if (Inventory.Num() <= InventorySize)
	{
		// 인벤토리에 아이템이 존재하는지 확인
		if (FindSlot(Item.ItemName) != -1)
		{
        		// 만약 인벤토리에 아이템이 존재한다면
            		// 인벤토리 배열에서 찾은 아이템 인덱스의 Quantity를 증가
			Inventory[FindSlot(Item.ItemName)].Quantity += Quantity;
		}
		else
		{
        	// 만약 인벤토리에 아이템이 존재하지 않는다면
            	// SlotStruct를 만들어서
			FSlotStruct Temp;
            	// 인벤토리에 더하려는 아이템 정보를 슬롯의 아이템 정보로 초기화
			Temp.ItemInfo = Item;
            	// SlotStruct의 Quantity (초깃값 0)에 매개변수 Quantity를 더해줌
			Temp.Quantity += Quantity;
            	// Inventory에 Temp라는 슬롯 추가 
			Inventory.Add(Temp);
		}
	}
   	// GameInstance의 인벤토리 정보 갱신
	CompOwner->GI->CurrentInventory = Inventory;
}

int32 FindSlot(FString ItemName);

int32 UHG_PlayerInventoryComponent::FindSlot(FString ItemName)
{
	// 인벤토리 배열의 모든 인덱스 순회
	for (int32 i = 0; i < Inventory.Num(); i++)
	{	
    		// 만약 현재 순회 중인 인덱스의 요소의 ItemName이 매개변수로 전달된 ItemName과 같다면
		if (Inventory[i].ItemInfo.ItemName == ItemName)
		{
        		// 현재의 인덱스를 반환
			return i;
		}
	}
    	// 모두 순회했지만 찾지 못했다면 -1을 반환
	return -1;
}

void RemoveFromInventory(FItemData Item, int32 Quantity);

void UHG_PlayerInventoryComponent::RemoveFromInventory(FItemData Item, int32 Quantity)
{
	// Item이라는 아이템 데이터를 갖는 슬롯이 존재하는지 확인
	if (FindSlot(Item.ItemName) != -1)
	{
    		// 존재한다면
        	// 찾은 인덱스의 아이템의 Quantity를 줄여준다.
        	// 여기서 인덱스의 Quantity가 0 이하로 내려가지 않도록 Clamp를 통해 최솟값을 0이 되도록함
		Inventory[FindSlot(Item.ItemName)].Quantity = FMath::Clamp(Inventory[FindSlot(Item.ItemName)].Quantity - Quantity, 0, InventorySize);
		// 만약 Quantity가 0이 됐다면
        	if (Inventory[FindSlot(Item.ItemName)].Quantity == 0)
		{ 
        		// 인벤토리에서 찾은 인덱스의 요소를 제거
			Inventory.RemoveAt(FindSlot(Item.ItemName));
		}
	}
    	// GameInstance의 현재 Inventory정보 저장
	CompOwner->GI->CurrentInventory = Inventory;
}

[UE5] 플레이어 공격의 충돌 처리 - ( ShapeComponent Sweep ) [2]

destroyer — Thu, 31 Oct 2024 06:00:10 +0900

최종 결과 영상

베지어 곡선

2차 베지어 곡선

베지어 곡선은, 조절점을 사용해 정의하는, 특별한 형태의 곡선이다. 2차 베지어 곡선은 시작점, 중간점, 끝점으로 만들어지는 곡선으로, 시작에서 중간점까지, 중간에서 끝점까지의 1차 베지어 곡선을 구한다. 시간 T에 대한 각각의 베지어 곡선의 지점 별로 위 그림과 같이 베지어 곡선을 한 번 더 구함으로써 곡선이 만들어지게 된다.

베지어 곡선 구성 과정

이 베지어 곡선을 이용해 이전 프레임과 현재 프레임의 위치를 직선이 아닌 곡선 이동 하도록 수정하고자 한다.

이전 프레임과 현재 프레임(초록색)의 중간 지점(빨간색)

우선 이전 프레임과 현재 프레임의 중간 지점을 구해서 디버그로 찍어보았다. 이 중간점을 기준으로 베지어 곡선을 만들어도, 세 점이 일직선 상에 있기 때문에 곡선이 만들어지지 않는다.

외적으로 제어점 구하기

외적을 이용해 적절한 곡선을 만들 제어점 위치 구하기

1. 이전 프레임 위치에서 현재 프레임 위치까지의 벡터(P2 - P1)의 단위벡터를 구한다.

2. 구한 단위벡터에 UP 벡터를 외적하여 수직이 되는 방향 벡터를 구한다.

3. P2-P1의 중간 지점으로부터 구한 수직 방향으로 (P2-P1)의 거리의 절반만큼 제어점을 이동시킨다.

4. 이동시킨 제어점을 기준으로 베지어 곡선을 구한다.

프레임 별 위치 (초록색) 제어점(빨간색)

각각의 프레임 위치에 대해 수직으로 뻗은 베지어 곡선 제어점을 확인할 수 있다.

이 제어점을 기준으로 베지어 곡선을 만들도록 코드를 수정하자.

베지어 곡선 적용한 코드

void AM4_PlayerWeaponSword::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    UCapsuleComponent* CapsuleComp = Cast<UCapsuleComponent>(CollisionComp);
    FVector CurrentWeaponLoc = CapsuleComp->GetComponentLocation();
    float CapsuleHalfHeight = CapsuleComp->GetScaledCapsuleHalfHeight();
    float CapsuleRadius = CapsuleComp->GetScaledCapsuleRadius();
    // 이전 위치가 설정되지 않은 경우 초기화
    if (PrevWeaponLoc.IsZero())
    {
        PrevWeaponLoc = CurrentWeaponLoc;
        return;
    }

    // 충돌 감지가 활성화된 경우에만 실행
    if (bOnCollision)
    {
        FVector Trajectory = CurrentWeaponLoc - PrevWeaponLoc;
        // 원형 궤적을 만들기 위한 제어점 계산
        FVector Forward = (CurrentWeaponLoc - PrevWeaponLoc).GetSafeNormal();
        FVector Right = FVector::CrossProduct(Forward, FVector::UpVector);
        FVector ControlPoint = (PrevWeaponLoc + CurrentWeaponLoc) * 0.5f;
        // 베지어 곡선 중간점 위치 살짝 틀어주기
        ControlPoint += Right * FVector::Dist(PrevWeaponLoc, CurrentWeaponLoc) * 0.5f;
        int NumSteps = FMath::CeilToInt(Trajectory.Size() / 30.0f); // 보간 스텝 수 결정
        for (int32 i = 0; i <= NumSteps; ++i)
        {
            float Alpha = i / static_cast<float>(NumSteps);
            FVector InterpolatedPosition = BezierLerp(PrevWeaponLoc, ControlPoint, CurrentWeaponLoc, Alpha);
           // 각 보간된 위치에서 충돌 감지 실행 ( 구현 예정 )

            // 디버그 캡슐을 표시하여 궤적 시각화
            DrawDebugCapsule(GetWorld(), InterpolatedPosition, CapsuleHalfHeight, CapsuleRadius, GetActorQuat(), FColor::Green, false, 1.f);
        }
    }
    // 이전 위치 업데이트
    PrevWeaponLoc = CurrentWeaponLoc;
}

FVector AM4_PlayerWeaponSword::BezierLerp(const FVector& Start, const FVector& Control, const FVector& End, float T)
{
    FVector Lerp1 = FMath::Lerp(Start, Control, T);
    FVector Lerp2 = FMath::Lerp(Control, End, T);
    return FMath::Lerp(Lerp1, Lerp2, T);
}

베지어 곡선을 적용한 궤적

어느정도 보완이 된 모습은 보이지만, 아직 완벽하게 보간되지는 않는다.

회전 보간

마지막으로 콜리전의 회전을 부드럽게 보간하려고 한다. 회전의 경우 정확하게 보간하기 위해 쿼터니언을 사용해 보간했다.

회전 보간까지 적용한 최종 코드

void AM4_PlayerWeaponSword::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    UCapsuleComponent* CapsuleComp = Cast<UCapsuleComponent>(CollisionComp);
    FVector CurrentWeaponLoc = CapsuleComp->GetComponentLocation();
    // 현재 회전
    FQuat CurrentRotation = GetActorQuat();
    float CapsuleHalfHeight = CapsuleComp->GetScaledCapsuleHalfHeight();
    float CapsuleRadius = CapsuleComp->GetScaledCapsuleRadius();
    // 이전 위치가 설정되지 않은 경우 초기화
    if (PrevWeaponLoc.IsZero())
    {
        PrevWeaponLoc = CurrentWeaponLoc;
        PrevWeaponRot = CurrentRotation;
        return;
    }

    // 충돌 감지가 활성화된 경우에만 실행
    if (bOnCollision)
    {
        FVector Trajectory = CurrentWeaponLoc - PrevWeaponLoc;
        // 원형 궤적을 만들기 위한 제어점 계산
        FVector Forward = (CurrentWeaponLoc - PrevWeaponLoc).GetSafeNormal();
        FVector Right = FVector::CrossProduct(Forward, FVector::UpVector);
        FVector ControlPoint = (PrevWeaponLoc + CurrentWeaponLoc) * 0.5f;
        // 베지어 곡선 중간점 위치 살짝 틀어주기
        ControlPoint += Right * FVector::Dist(PrevWeaponLoc, CurrentWeaponLoc) * 0.5f;
        int NumSteps = FMath::CeilToInt(Trajectory.Size() / 30.0f); // 보간 스텝 수 결정
        for (int32 i = 0; i <= NumSteps; ++i)
        {
            float Alpha = i / static_cast<float>(NumSteps);
            FVector InterpolatedPosition = BezierLerp(PrevWeaponLoc, ControlPoint, CurrentWeaponLoc, Alpha);
            // 회전 보간 추가
            FQuat InterpolatedRotation = FQuat::Slerp(PrevWeaponRot, CurrentRotation, Alpha);
            // 각 보간된 위치에서 충돌 감지 실행 ( 구현 예정 )

            // 디버그 캡슐을 표시하여 궤적 시각화
            DrawDebugCapsule(GetWorld(), InterpolatedPosition, CapsuleHalfHeight, CapsuleRadius, InterpolatedRotation, FColor::Green, false, 1.f);
        }
    }
    // 이전 위치 업데이트
    PrevWeaponLoc = CurrentWeaponLoc;
    // 이전 회전 업데이트
    PrevWeaponRot = CurrentRotation;
}

최종 보간 결과

대 만 족

[UE5] 플레이어 공격의 충돌 처리 ( ShapeComponent Sweep ) [1]

destroyer — Tue, 29 Oct 2024 17:19:06 +0900

플레이어 타격 충돌 처리

전투 시스템에서 타격 판정은 매우 중요한 요소이다. 정교하게 타격 판정이 이루어 질 수록 타격 감각을 세밀하게 구현할 수 있다.

특히 속도가 빠른 애니메이션의 경우, 프레임 단위로 충돌 체크를 하면 타격 판정에 빈 구간이 눈에 띄게 나타난다.

타격에 빈 구간이 많은 기본 충돌 체크

기본 선형 보간

void AM4_PlayerWeaponSword::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    FVector CapsuleLocation = CapsuleComp->GetComponentLocation();
    FVector CurrentWeaponLoc = CapsuleComp->GetComponentLocation();
    float CapsuleHalfHeight = CapsuleComp->GetScaledCapsuleHalfHeight();
    float CapsuleRadius = CapsuleComp->GetScaledCapsuleRadius();

    // 이전 위치가 설정되지 않은 경우 초기화
    if (PrevWeaponLoc.IsZero())
    {
        PrevWeaponLoc = CurrentWeaponLoc;
        return;
    }

    // 충돌 감지가 활성화된 경우에만 실행
    if (bOnCollision)
    {
        FVector Trajectory = CurrentWeaponLoc - PrevWeaponLoc;
        int NumSteps = FMath::CeilToInt(Trajectory.Size() / 20.0f); // 보간 스텝 수 결정

        for (int i = 0; i <= NumSteps; ++i)
        {
            float Alpha = i / static_cast<float>(NumSteps);
            FVector InterpolatedPosition = FMath::Lerp(PrevWeaponLoc, CurrentWeaponLoc, Alpha);

            // 보간된 위치에서의 충돌 처리 추가하기

            // 디버그 캡슐을 표시하여 궤적 시각화
            DrawDebugCapsule(GetWorld(), InterpolatedPosition, CapsuleHalfHeight, CapsuleRadius, GetActorRotation().Quaternion(), FColor::Green, false, 0.1f);

        }

    }
    // 이전 위치 업데이트
    PrevWeaponLoc = CurrentWeaponLoc;
}

이전 위치를 저장해두고, 보간 Step만큼 반복하여 현재 위치와 이전 위치를 선형 보간하는 방식으로 구현했다.

키 프레임 콜리전 위치 예시

다음과 같이 키 프레임 이 존재한다고 했을 때

위치 보간 작용

이러한 방식으로 콜리전의 위치를 보간 하여 빈 공간을 메꾸는 방식

빈 공간이 확연이 사라진 것을 볼 수 있었다.

하지만 검을 휘두른다고 생각했을 때 머릿속에서 생각나는 궤적과는 차이가 나는 모습. 검이 원형을 그리며 부드럽게 그려지지 않고 각진 형태로 그려진다.