지훈

26.06.24 TIL / 3D 게임 개발 챕터4 정리 완료, 과제 5번 준비

jh009 — Wed, 24 Jun 2026 20:06:56 +0900

오늘

C++와 Unreal Engine으로 3D 게임 개발 정리 완료

https://jh009.tistory.com/85

C++와 Unreal Engine으로 3D 게임 개발 4-3

4-3. UI 애니메이션 효과 및 3D 위젯 UI 구현하기 1. UI 애니메이션 효과 디자인하기 UMG와 Animation에 대한 이해언리얼 엔진에서는 UI를 만들 때 주로 UMG 사용 (Unreal Motion Graphics)UMG에는 Animation 기능이

jh009.tistory.com

https://jh009.tistory.com/86

C++와 Unreal Engine으로 3D 게임 개발 4-4

4-4. 파티클과 사운드로 게임 효과 연출하기 1. 파티클 시각 효과 추가하기 파티클 시스템 (Particla System) 기본 개념 이해 게임 내에서 불꽃, 연기, 폭발, 먼지 등 다양한 시각적 효과를 구현하기 위

jh009.tistory.com

5번 과제 필수 구현 기능 준비

3단계 레벨 전환을 구현하기 위해 Level_1_Map, Level_2_Map, Level_3_Map 총 3개의 맵을 생성하였음

시각적 구분 요소 추가

각 맵을 직관적으로 구분하기 위해 맵 상단에 숫자 1, 2, 3 형태의 도트 오브젝트를 배치하여 레벨 환경을 구성하였음

회고

C++와 언리얼 엔진을 활용한 3D 게임 개발 강의를 수강 완료하였다. (강의 정리한 내용을 바탕으로 복습을 진행할 예정)

내일부터는 과제 필수 구현 기능을 시작할 것이다.

3번의 레벨 전환이 필요한 만큼, 혼동을 방지하고자 각 맵마다 큐브를 활용해 숫자 오브젝트를 배치하여 시각적 직관성을 확보했다.

C++와 Unreal Engine으로 3D 게임 개발 4-4

jh009 — Wed, 24 Jun 2026 17:06:54 +0900

4-4. 파티클과 사운드로 게임 효과 연출하기

1. 파티클 시각 효과 추가하기

파티클 시스템 (Particla System) 기본 개념 이해

게임 내에서 불꽃, 연기, 폭발, 먼지 등 다양한 시각적 효과를 구현하기 위한 도구
다수의 작은 입자 (Particle)들이 모여 움직이면서 특정한 모양, 색상, 혹은 애니메이션 효과를 만들어냄
언리얼 엔진에서는 파티클 시스템을 사용해 효과적인 VFX (Visual Effects) 를 구현할 수 있도록 기능을 제공

Cascade / Niagara

Cascade

언리얼 엔진 3 시절부터 제공된 오래된 파티클 편집 툴

언리얼 엔진 4, 5 호환 가능 / 신규 기능 업데이트 → 주로 Niagara 위주로 이루어지고 있음

상대적으로 간단하고 빠르게 결과를 볼 수 있음
레거시 프로젝트나 기존 아티스트 툴체인에서 많이 사용
복잡하거나 고급스러운 VFX 연출에는 한계

Niagara

언리얼 엔진 4 후반부터 새롭게 도입된 차세대 파티클 시스템

언리얼 엔진 5에서 공식적으로 권장되는 방식

모듈 단위로 다양한 파티클 동작을 정교하게 제어 가능
블루프린트나 머티리얼, 스크립팅과 유기적으로 연동되어 고급 VFX를 쉽게 만들 수 있음
GPU 파티클, 신규 기능 업데이트가 빠르게 적용

파티클 효과를 빠르게 만들어봐야 한다면 Cascade

새 프로젝트를 계획 중이고 고급 이펙트를 구현하고 싶다면 Niagara 학습을 권장

이름 앞에 P_ 또는 Niagara_ 와 같은 접두어를 붙여두면, 프로젝트 내에서 파티클 에셋을 쉽게 구분할 수 있음

아이템 획득에 파티클 적용 / 사운드 효과 추가

모든 아이템은 상호작용 시 ActivateItem 함수를 실행하도로 설계 했음

여기에 파티클을 붙인다면 BaseItem을 상속받는 아이템들 모두에서 파티클을 설정할 수 있음

BaseItem.h

파티클 적용

사운드 적용

BaseItem.cpp

파티클 적용

사운드 효과 추가

Details 창 → Item 카테고리 → Effects 라는 카테고리가 생긴 것을 확인 가능

Particle 과 Sound 를 원하는 것으로 할당 후 컴파일 저장

지뢰 아이템에 파티클 적용 / 사운드 효과 추가

MineItem.h

파티클 적용

사운드 효과 추가

MineItem.cpp

파티클 적용

사운드 효과 추가

C++와 Unreal Engine으로 3D 게임 개발 4-3

jh009 — Wed, 24 Jun 2026 15:46:51 +0900

4-3. UI 애니메이션 효과 및 3D 위젯 UI 구현하기

1. UI 애니메이션 효과 디자인하기

UMG와 Animation에 대한 이해

언리얼 엔진에서는 UI를 만들 때 주로 UMG 사용 (Unreal Motion Graphics)

UMG에는 Animation 기능이 탑재되어 있음

→ 버튼이 클릭될 때 색이 바뀌거나, 텍스트가 화면 위로 등장했다가 사라지는 등 다양한 연출을 쉽게 구현 가능

Animation 패널

UMG 에디터 내에서 메뉴 상단에서 Window - Animations를 클릭하면 애니메이션을 다루는 창이 뜸
UMG 에디터 왼쪽 하단 (기본 레이아웃 기준)에 위치한 패널
여기서 새 애니메이션을 생성하거나, 이미 만든 애니메이션을 선택해 타임라인을 확인

Keyframe(키 프레임)

특정 시간대에 UI 속성(크기, 위치, 투명도, 색상 등)을 어떻게 바꿀지를 기록하는 지점
여러 개의 키 프레임을 연결하여 하나의 애니메이션 타임라인을 완성

Text 위젯에 애니메이션 적용하기

WBP_MainMenu → 디자이너 화면 TextBlock 2개 추가 → 이름 설정 GameOverText / TotalScoreText

두 TextBlock 모두 기본 Text를 설정 (Content - Text 카테고리에 입력)

GameOverText와 TotalScoreText를 Hidden (또는 Opacity=0) 상태로 배치

게임 시작 시 바로 보이지 않도록, TextBlock의 Visibility를 Hidden 으로 설정

애니메이션으로 텍스트를 천천히 보이게 할 것임

애니메이션 트랙 생성

GameOverText를 누른 상태로 + Animation 새 애니메이션 추가 → 이름 설정 Anim_TimeOver

+ Add 를 클릭하고 GameOverText를 선택

Keyframe (키 프레임) 설정

Render Opacity (투명도)를 트랙에 추가

시간 바를 옮기면서 각각 Render Opacity 값을 변경하면 자동으로 트랙에 Key가 등록됨

애니메이션을 Blueprint 재생 함수로 묶어두기

이벤트 그래프에서 PlayGameOverAnim Function을 만들기

Details 패널 → GameOverText → is Variable 체크

PlayTimeOverAnim을 호출하면 Anim_TimeOver 애니메이션이 재생되도록 구성

애니메이션 재생이 끝나면 자연스럽게 점수가 뜰 수 있도록, TotalScoreText 를 visible 처리를 하도록 연결

2. 게임 오버 UI 애니메이션 효과 추가하기

최종 점수 표시 애니메이션 호출

// SpartaPlayerController.cpp

void ASpartaPlayerController::ShowMainMenu(bool bIsRestart)
{
	if (HUDWidgetInstance)
	{
		HUDWidgetInstance->RemoveFromParent();
		HUDWidgetInstance = nullptr;
	}

	if (MainMenuWidgetInstance)
	{
		MainMenuWidgetInstance->RemoveFromParent();
		MainMenuWidgetInstance = nullptr;
	}

	if (MainMenuWidgetClass)
	{
		MainMenuWidgetInstance = CreateWidget<UUserWidget>(this, MainMenuWidgetClass);
		if (MainMenuWidgetInstance)
		{
			MainMenuWidgetInstance->AddToViewport();
			
			bShowMouseCursor = true;
			SetInputMode(FInputModeUIOnly());
		}
		
		if (UTextBlock* ButtonText = 
        Cast<UTextBlock>(MainMenuWidgetInstance->GetWidgetFromName(TEXT("StartButtonText"))))
		{
			if (bIsRestart)
			{
				ButtonText->SetText(FText::FromString(TEXT("Restart")));
			}
			else
			{
				ButtonText->SetText(FText::FromString(TEXT("Start")));
			}
		}

// 추가
		if (bIsRestart)
		{
			UFunction* PlayAnimFunc = 
			MainMenuWidgetInstance->FindFunction(FName("PlayGameOverAnim"));
			if (PlayAnimFunc)
			{
				MainMenuWidgetInstance->ProcessEvent(PlayAnimFunc, nullptr);
			}
			
			if (UTextBlock* TotalScoreText = Cast<UTextBlock> 
			   (MainMenuWidgetInstance->GetWidgetFromName("TotalScoreText")))
			{
				if (USpartaGameInstance* SpartaGameInstance = Cast<USpartaGameInstance>
				   (UGameplayStatics::GetGameInstance(this)))
				{
					TotalScoreText->SetText(FText::FromString(
					FString::Printf(TEXT("Total Score: %d"), 
					SpartaGameInstance->TotalScore)));
				}
			}
		}
	}
}

3. WidgetComponent로 캐릭터 체력 표시하기

WidgetComponent 개념 이해

UMG (언리얼 모션 그래픽스)로 만든 위젯 (텍스트, 이미지, 버튼 등)을 3D 월드에 붙일 수 있게 해주는 컴포넌트

예시: “NPC 머리 위 체력바”, “아이템 위에 ‘F 키를 누르세요’ 텍스트” 등

언리얼 엔진에서 WidgetComponent를 사용하면,

2D로만 보이던 UI를 공간 내 특정 위치에 붙여 놓고, 카메라 각도에 따라 회전하거나 크기가 달라지는 모습을 만들 수 있음

Actor에 부착(Attach)할 수 있는 컴포넌트 특정 UUserWidget(UMG Blueprint 클래스)을 3D 상에 표시하게 해줌

보통은 SetWidgetSpace(EWidgetSpace::World)로 설정하여, 월드 공간에 UI 가 존재하게 만듦
초기 상태에서 SetVisibility(false)로 해 두고, 플레이어가 가까이 왔을 때 SetVisibility(true)로 변경하여 표시할 수 있음

Widget Blueprint 준비하기

Contents Browser → UI - Widgets 폴더

User Interface → Widget Blueprint - User Widget 선택

새 위젯 블루프린트 만들기 → 이름 설정 WBP_HP

WBP_HP

Palette → Common - Text 선택 → 이름 설정 OverHeadHP

‘10 / 100’ 과 같이 예시 텍스트를 임시로 입력

폰트 종류, 크기, 색상 등은 자유롭게 설정

Character 클래스에 WidgetComponent 추가

SpartaCharacter.h

SpartaCharacter.cpp

OverheadWidget->SetWidgetSpace(EWidgetSpace::Screen);

스크린 모드: UI가 항상 화면에 고정된 것처럼 보임 / 플레이어의 카메라 방향과 상관없이 항상 정면에서 보임

월드 모드: 캐릭터의 움직임에 따라 글씨도 같이 돌아감

Character 클래스에서 WidgetComponent 위치 설정

BP_SpartaCharacter → Components 중 Overhead Widget 선택

→ User Interface 카테고리 → Widget Class를 WBP_HP로 설정

→ Space는 World로 우선 셋팅을 한 후 위젯의 위치와 크기 조정

(Screen으로 설정해 놓으면 블루프린트 상에서 위젯이 보이지 않을 수 있음)

수정 후 Space를 다시 Screen으로 설정

캐릭터 사망하였을 시 처리 로직 추가

SpartaCharacter.cpp

SpartaGameState.cpp

SpartaPlayerController.cpp

수정 이후 테스트 진행하기

26.06.23 TIL / 3D 게임 개발 강의 정리, 방어 코드 짜보기

jh009 — Tue, 23 Jun 2026 20:41:49 +0900

오늘

C++와 Unreal Engine으로 3D 게임 개발 정리

https://jh009.tistory.com/81

C++와 Unreal Engine으로 3D 게임 개발 4-1

4-1. UI 위젯 설계와 실시간 데이터 연동하기 1. UMG (Unreal Motion Graphics) 위젯 기초 디자인 이해하기 HUD (Heads-Up Dispaly)게임 내에서 플레이어에게 정보를 제공하기 위한 화면게임 중 화면의 일부에 배

jh009.tistory.com

https://jh009.tistory.com/83

C++와 Unreal Engine으로 3D 게임 개발 4-2

4-2. 게임 흐름에 맞춘 메뉴 UI 구현하기 1. 게임 메뉴 UI 디자인하기 메뉴 위젯 생성하고 버튼 추가 UI 폴더 우클릭 → User Interface → Widget Blueprint 선택 → 위젯 이름 설정 WBP_MainMenu Canvas Panel을 놓아

jh009.tistory.com

기초반 3강 정리

https://jh009.tistory.com/82

기초반 3강 / 컨트롤러, 총기 구현

폴더 정리BP_PlayerCharacter → Characters/Player/로 이동Characters 폴더 우클릭 → Update Redirector References 폴더를 나눠서 관리하는 이유:나중에 몬스터도 추가될 예정이기에 미리 분리해놓으면 헷갈리는 일

jh009.tistory.com

주의점

1. PIE 모드 실행 시 언리얼 에디터 Crash

기초반 3강 컨트롤러 / 총기 구현 중 언리얼 에디터 Crash

문제 현상

SetupPlayerInputComponent 코드 수정 후 언리얼 에디터에서 PIE 실행 시 엔진 크래시 발생

원인 분석

코드 로직에 오류가 없는 것을 확인했고,

BP_PlayerCharacter의 Details 패널 내 Input - Player Input Config 설정이 None으로 비어있는 것을 발견

해결책

BP_PlayerCharacter의 Details 패널 → Player Input Config 항목을 DA_PlayerInputConfig 로 할당

코드 수정을 했다면 언리얼에디터도 같이 수정해주고 PIE를 누르기

방어 코드 추가 / if (PlayerInputConfig == nullptr) return;

Crash를 방지 가능
어떤 문제인지 로그를 통해 바로 파악 가능

void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

    // 데이터가 할당되었는지 안전하게 확인
    if (PlayerInputConfig == nullptr)
    {
        UE_LOG(LogTemp, Error, TEXT("PlayerInputConfig가 BP에서 설정되지 않았음."));
        return; 
    }
}

2. 언리얼 에디터 Fab 로그인 확인

언리얼 에디터 안에서 Fab을 접속할 때 로그인이 풀리는 경우가 있음

로그인이 안되어 있다면, 다운로드가 되지 않음

키워드 정리 [ Reflection, 가비지 컬렉터(UPROPERTY, UObject/TSubclassOf) ]

1. 리플렉션(Reflection)

프로그램이 실행 중, 자기 자신의 구조(클래스, 멤버 변수, 함수 등)를 조사하고 조작할 수 있는 기능을 의미

C++은 원래 리플렉션을 지원하지 않지만, 언리얼은 UHT(Unreal Header Tool)를 통해 구현

필요한 이유

에디터에서 변수 값을 수정하기 위함
가비지 컬렉터가 객체의 참조 관계를 파악하기 위함
블루프린트와 C++ 간의 상호작용(함수 호출, 변수 노출)

UCLASS(), USTRUCT(), UPROPERTY(), UFUNCTION() 등이 붙은 항목만 리플렉션 시스템에 등록

2. 가비지 컬렉터, GC (Garbage Collector)

언리얼 엔진은 C++의 수동 메모리 관리 대신, 참조 기반 가비지 컬렉션 시스템을 사용

시스템은 UObject를 상속받은 객체들을 추적

더 이상 어디에서도 참조되지 않는 객체를 주기적으로 찾아 메모리에서 해제

* UObject 기반 객체는 new가 아닌 NewObject<T>()로 생성해야 함

GC가 객체를 안전하게 해제하려면,

해당 객체를 가리키는 포인터가 UPROPERTY()로 마킹되어 있어야 함

(GC가 누가 이 객체를 참조하고 있는지 알 수 있음)

3. UPROPERTY()

리플렉션과 GC를 연결하는 가장 중요한 매크로

변수 위에 선언하여 엔진에게 이 변수의 정보를 알려줌

GC 보호:

UPROPERTY()로 선언된 UObject* 포인터는 GC 시스템에 의해 참조 카운트가 관리

이 변수가 살아있는 한, 가리키는 객체는 메모리에서 삭제 X

데이터 직렬화:

에디터에서 값을 저장, 블루프린트로 노출, 네트워크로 데이터를 전송할 때 필요

주요 옵션:

EditAnywhere: 에디터 어디서든 수정 가능
BlueprintReadOnly / BlueprintReadWrite: 블루프린트에서 접근 가능 여부
Category: 에디터 디테일 패널에서 항목 그룹화

4. UObject와 TSubclassOf

UObject

언리얼 엔진의 모든 클래스가 상속받는 최상위 베이스 클래스
가비지 컬렉션, 리플렉션, 직렬화 등 엔진의 핵심 기능을 모두 지원 받을 수 있음

TSubclassOf

특정 클래스의 타입만 허용하는 템플릿 클래스
사용 예시: TSubclassOf<AActor> 라고 선언 → 에디터에서 AActor를 상속받은 블루프린트 클래스만 선택할 수 있게 제한
장점: 코딩 시 불필요한 타입 체크를 줄임, 에디터에서 디자이너가 잘못된 클래스를 할당하는 실수를 방지

회고

C++와 Unreal Engine으로 3D 게임 개발 강의 챕터4 정리가 거의 끝났다.

내일쯤이면 강의 정리를 다 하고 과제 5번 시작을 해도될 것 같다.

기초반 3강 예습 도중, 특정 상황에 Crash가 나서 원인 분석과 해결책까지 정리했다.

그리고 추가로 방어 코드도 따로 작성해보았다.

방어 코드 if (PlayerInputConfig == nullptr) return; 가 있어서

Input - Player Input Config 설정이 None 으로 되어있어도 Crash까지는 일어나지 않았다.

그리고 리플렉션과 UPROPERTY 를 정리해보았는데, 이해가 갈듯말듯하다. 좀 더 정리가 필요하다.

C++와 Unreal Engine으로 3D 게임 개발 4-2

jh009 — Tue, 23 Jun 2026 20:12:25 +0900

4-2. 게임 흐름에 맞춘 메뉴 UI 구현하기

1. 게임 메뉴 UI 디자인하기

메뉴 위젯 생성하고 버튼 추가

UI 폴더 우클릭 → User Interface → Widget Blueprint 선택 → 위젯 이름 설정 WBP_MainMenu

Canvas Panel을 놓아서 기본적인 바탕 마련

Border :

Details - Size X → 1920, Size Y → 1080

Brush Color → RGB 색깔 선택 후, 맨 아래 A (투명도) 도 취향에 맞게 설정

Common - Button 위젯 → Start 버튼 하나만 Canvas Panel 아래에 두기

Button 이름 → StartButton

Alignment를 (0.5, 0.5)로 놓고 X, Y의 위치를 화면 크기의 절반으로 두면 가운데에 딱 배치

각 버튼마다 Common - Text를 끌어다 놓기 (왼쪽 하단에 Hierarchy 창에 드래그 앤 드랍을 하면 편함)

Text 이름 → StartButtonText

메뉴 레벨 생성하고 설정하기

흔히 게임 개발 시 메뉴 전용 맵을 만들고, 그 맵에서는 메뉴만 띄우도록 하고, 실제 게임이 시작되면 게임 레벨로 넘어가게 함
이 방식을 쓰면 Menu UI 와 Game Level 이 완전히 분리되어, 구조가 좀 더 명확해짐

File - New Level 선택 → Basic 템플릿 생성, Maps 폴더 → MenuLevel 이름으로 저장

Editor - Project Settings → Maps & Modes → Default Maps 를 MenuLevel 로 지정

2. 게임 흐름 내에 메뉴 UI 배치하기

WBP_MainMenu 을 다양한 상황에서 표시하고, 숨기고, 다시 띄우는 로직을 단계별로 구현

플레이 버튼을 누르면 Menu UI가 가장 먼저 뜨기
게임 시작 시 자동으로 HUD를 띄우기
메뉴가 나타날 때마다, UI 입력 모드로 전환하여 버튼 클릭에 집중하게 만드는 방식으로 수정
게임이 종료되면 메뉴가 다시 뜨도록 만들기

PlayerController에 기본 위젯 오픈 함수 구현

PlayerController가 UI를 다루기 좋음

게임 모드도 가능하지만, 멀티플레이를 고려하면 PlayerController가 UI 담당이 좀 더 자연스러운 편

SpartaPlayerController.h

SpartaPlayerController.cpp

1. 기본 원리

PlayerController의 SetInputMode 함수를 통해 입력을 UI에 집중시킬지, 게임에 집중시킬지 결정

2. UI 전용 모드 전환 (UI Only)

메뉴 호출 시 캐릭터 조작을 막고 UI 입력만 받기 위한 단계

구조체 설정: FInputModeUIOnly 생성 및 SetWidgetToFocus 로 포커스 대상(위젯) 지정
모드 적용: SetInputMode (InputMode) 호출
시각화: bShowMouseCursor = true 로 설정

3. 에디터 세팅

BP_SpartaPlayerController 의 MainMenuWidgetClass 변수에 WBP_MainMenu 위젯을 할당해야 함

SetInputMode로 입력 대상을 UI로 바꾸고, 마우스를 띄운 뒤, 컨트롤러에 위젯 클래스를 연결

→ 마우스로 UI만 누를 수 있게 됨

// 메뉴 UI 표시
void ASpartaPlayerController::ShowMainMenu(bool bIsRestart)
{
	// HUD가 켜져 있다면 닫기
	if (HUDWidgetInstance)
	{
		HUDWidgetInstance->RemoveFromParent();
		HUDWidgetInstance = nullptr;
	}
	
	// 이미 메뉴가 떠 있으면 제거
	if (MainMenuWidgetInstance)
	{
		MainMenuWidgetInstance->RemoveFromParent();
		MainMenuWidgetInstance = nullptr;
	}
	
	// 메뉴 UI 생성
	if (MainMenuWidgetClass)
	{		
		MainMenuWidgetInstance = CreateWidget<UUserWidget>(this, MainMenuWidgetClass);
		if (MainMenuWidgetInstance)
		{
			MainMenuWidgetInstance->AddToViewport();
			
			bShowMouseCursor = true;
			SetInputMode(FInputModeUIOnly());
		}
		
		if (UTextBlock* ButtonText = Cast<UTextBlock>
        (MainMenuWidgetInstance->GetWidgetFromName(TEXT("StartButtonText"))))
		{
			if (bIsRestart)
			{
				ButtonText->SetText(FText::FromString(TEXT("Restart")));
			}
			else
			{
				ButtonText->SetText(FText::FromString(TEXT("Start")));
			}
		}
	}
}

// 게임 HUD 표시
void ASpartaPlayerController::ShowGameHUD()
{
	// HUD가 켜져 있다면 닫기
	if (HUDWidgetInstance)
	{
		HUDWidgetInstance->RemoveFromParent();
		HUDWidgetInstance = nullptr;
	}
	
	// 이미 메뉴가 떠 있으면 제거
	if (MainMenuWidgetInstance)
	{
		MainMenuWidgetInstance->RemoveFromParent();
		MainMenuWidgetInstance = nullptr;
	}

	if (HUDWidgetClass)
	{
		HUDWidgetInstance = CreateWidget<UUserWidget>(this, HUDWidgetClass);
		if (HUDWidgetInstance)
		{
			HUDWidgetInstance->AddToViewport();
			
			bShowMouseCursor = false;
			SetInputMode(FInputModeGameOnly());
			
			ASpartaGameState* SpartaGameState 
			= GetWorld() ? GetWorld()->GetGameState<ASpartaGameState>() : nullptr;
			if (SpartaGameState)
			{
				SpartaGameState->UpdateHUD();
			}
		}
	}
}

// 게임 시작 - BasicLevel 오픈, GameInstance 데이터 리셋
void ASpartaPlayerController::StartGame()
{
	if (USpartaGameInstance* SpartaGameInstance 
		= Cast<USpartaGameInstance>(UGameplayStatics::GetGameInstance(this)))
	{
		SpartaGameInstance->CurrentLevelIndex = 0;
		SpartaGameInstance->TotalScore = 0;
	}
	
	UGameplayStatics::OpenLevel(GetWorld(), FName("BasicLevel"));
}

GameState에서 게임 흐름에 따라 UI 호출

SpartaGameState.cpp 수정

메뉴 UI가 PlayerController에 설정이 되었나 확인하기

BP_SpartaPlayerController → Menu - Main Menu Widget Class → WBP_MainMenu 로 설정 (메인 메뉴 추가하기)

Start 버튼 클릭 이벤트에 함수 바인딩

Designer 탭에서 StartButton 버튼을 선택 → Is Variable 체크

맨 하단에 Events 활성화 → On Clicked 옆에 + 클릭

OnClicked (StartButton) 이벤트 노드가 자동 생성 이벤트 노드가 자동 생성 되며, 로직을 구현할 수 있음

PlayerController에서 Start Game함수를 가져와서 연결

PlayerController 상에서 메뉴를 다 연결했다면 SpartaPlayerController.cpp → HUDWidget 부분 삭제하기

BeginPlay → 레벨을 새로 갱신할 때마다 PlayerController가 다시 만들어지게 코드를 수정하였음

위젯 생성을 매번 하지 않도록 코드를 정리

현재 맵이 메인 메뉴 맵인 경우에만 메인 메뉴 위젯을 화면에 띄우도록 조건을 추가

메인 메뉴 화면일 때만 메인 메뉴 UI를 띄우는 작업으로 이해하면 됨

// SpartaPlayerController.cpp

// 삭제할 부분
if (HUDWidgetClass)
{
	HUDWidgetInstance = CreateWidget<UUserWidget>(this, HUDWidgetClass);
    if (HUDWidgetInstance)
    {
    	HUDWidgetInstance->AddToViewport();
    }
}

기초반 3강 / 컨트롤러, 총기 구현

jh009 — Tue, 23 Jun 2026 12:47:05 +0900

폴더 정리

BP_PlayerCharacter → Characters/Player/로 이동

Characters 폴더 우클릭 → Update Redirector References

폴더를 나눠서 관리하는 이유:

나중에 몬스터도 추가될 예정이기에 미리 분리해놓으면 헷갈리는 일이 줄어듦

UPlayerInputConfigDataAsset C++ 클래스 만들기

New C++ Class → DataAsset 생성 → 이름설정 PlayerInputConfigDataAsset

PlayerInputConfigDataAsset.h 내용 추가

PlayerInputConfigDataAsset.h

DA_PlayerInputConfig 인스턴스 만들기

Content/Input → Miscellaneous → Data Asset → 이름 설정 DA_PlayerInputConfig

DA_PlayerInputConfig → Context, Actions 설정

PlayerCharacter.h

InputMappingContext, Move, Look, Jump 삭제

PlayerCharacter.h

PlayerInputConfig 추가

PlayerCharacter.h

PlayerCharacter.cpp

#include "PlayerInputConfigDataAsset.h" 추가

PlayerCharacter.cpp

BeginPlay 수정

PlayerCharacter.cpp

SetupPlayerInputComponent 수정

PlayerCharacter.cpp

BP_PlayerCharacter 슬롯 갱신

Player Input Config → DA_PlayerInputConfig 할당 → PIE 테스트 진행

총기 시스템 기초 / 메시 컴포넌트 + 무기 데이터

FPS_Weapon_Bundle 다운

언리얼 에디터 → Fab으로 접속할 때 가끔 로그인이 풀리는 경우가 있음 → 그럴 경우 다운이 아예 안되는 경우가 있으니 주의

External 폴더 → Move Here → External 폴더 Update Redirector References

FPS_Weapon_Bundle 삭제

언리얼 에디터, 폴더 안에 있는 FPS_Weapon_Bundle 탐색기로 들어가서 수동으로 삭제하기

삭제 후 Content 폴더 확인

EquippedWeaponMesh 컴포넌트 추가

무기 메시를 들고 다닐 슬롯 1개를 캐릭터에 추가

PlayerCharacter.h

PlayerCharacter.h

PlayerCharacter.cpp

PlayerCharacter.cpp

BP_PlayerCharacter → EquippedWeaponMesh 생성되었는지 확인

UWeaponDataAsset C++ 클래스 만들기

New C++ Class → DataAsset 생성 → 이름설정 WeaponDataAsset

WeaponDataAsset.h

BlueprintType → enum 타입을 블루프린트 변수나 핀 타입으로 쓸 수 있게 노출하는 지정자

FTransform = Location + Rotation + Scale 을 한 묶음으로 담는 구조체

FTransform::Identity → 추가 보정 없음 (기본값)

Location (0,0,0)
Rotation (0,0,0)
Scale (1,1,1)

DA_Weapon_Sniper / Grenade / Machine 인스턴스 만들기

1. Content 파일에 Weapons 폴더 생성

2. Miscellaneous → Data Asset → 부모 WeaponDataAsset 3개 생성

이름 설정 DA_Weapon_Grenade / DA_Weapon_Machine / DA_Weapon_Sniper

WeaponType, Mesh, Damage 설정

DA_Weapon_Grenade

DA_Weapon_Machine

DA_Weapon_Sniper

무기 전환 입력

IA 3개 추가 (Sniper / Grenade / Machine)

에셋 이름	Value Type
IA_Sniper	Digital (bool)
IA_Grenade	Digital (bool)
IA_Machine	Digital (bool)

IMC 키 매핑

IMC_PlayerInputMapping

A_Sniper → 키 1

IA_Grenade → 키 2

IA_Machine → 키 3

PIC에 슬롯 추가

PlayerInputConfigDataAsset.h

DA_PlayerInputConfig (IA_Sniper, IA_Grenade, IA_Machine 슬롯 채우기)

APlayerCharacter에 무기 전환 로직

PlayerCharacter.h

PlayerCharacter.h

PlayerCharacter.cpp

PlayerCharacter.cpp

BeginPlay 끝에 기본 무기 장착

PlayerCharacter.cpp

SetupPlayerInputComponent 바인딩 추가

PlayerCharacter.cpp

BP_PlayerCharacter에 DA 3개 할당

BP_PlayerCharacter Class Defaults → Weapon 카테고리에 에셋 할당

PIE 테스트 / 무기 전환

게임 플레이 시

1번 → Sniper (이미 들고 있음)

2번 → Grenade

3번 → Machine

메시가 손에서 어색하지 않게 DA_Weapon_ → AttachTransform 조정

발사 / 저격 라인 트레이스

IA_Fire 추가 / Value Type : Digital bool

IMC_PlayerInputMapping → Left Mouse Button → IA_Fire 매핑

PIC에 FireAction 추가

PlayerInputConfigDataAsset.h

APlayerCharacter → FireGun

PlayerCharacter.h

PlayerCharacter.h

PlayerCharacter.cpp

PlayerCharacter.cpp

SetupPlayerInputComponent 바인딩 추가

PlayerCharacter.cpp

최종 PIE 테스트

이동: WASD / 마우스 시점

점프: Space

무기 전환: 1 (저격) / 2 (유탄) / 3 (머신건)

발사: 마우스 좌클릭

좌클릭 시 1번 무기 저격일때만 빨간 라인 + 충돌점 노란 구가 생기는 것을 확인 가

Output Log 창 바닥에 HIT 되어서 50의 데미지가 들어간 것을 확인

C++와 Unreal Engine으로 3D 게임 개발 4-1

jh009 — Tue, 23 Jun 2026 10:02:13 +0900

4-1. UI 위젯 설계와 실시간 데이터 연동하기

1. UMG (Unreal Motion Graphics) 위젯 기초 디자인 이해하기

HUD (Heads-Up Dispaly)

게임 내에서 플레이어에게 정보를 제공하기 위한 화면
게임 중 화면의 일부에 배치
플레이어가 현재 게임 상황을 이해하는 데 필요한 체력, 미니맵, 퀘스트 업데이트와 같은 데이터를 제공

언리얼 엔진의 HUD 시스템

Canvas 기반 HUD
- AHUD 클래스를 상속하여 구현
- 기본적인 2D 그리기 작업(텍스트, 이미지 등) 가능
- 레거시 방식으로 간주되며, 간단한 HUD에 적합
UMG (Unreal Motion Graphics)
- 언리얼 엔진의 Widget Blueprint를 이용한 UI 시스템
- 더 직관적이고 강력한 HUD 디자인 가능
- 다양한 위젯(Text, Button, Image 등)을 사용하여 HUD를 제작

위젯 블루프린트 (Widget Blueprint)

언리얼 엔진에서 UI (User Interface)를 시각적으로 설계할 수 있도록 제공되는 에디터용 블루프린트

Contents 하위에 UI 폴더 생성 → 그 하위에 Widget 폴더

Widget 폴더에서 우클릭 → User Interface → Widget Blueprint 선택 → 이름설정 (WBP_HUD)

UI 요소 (UI Elements)

왼쪽 상단 Palette 탭 → 다양한 UI 요소들을 제공

Text Block: 캐릭터 체력, 점수, 남은 시간 등 텍스트를 보여줄 때
Button: Start Game, Quit Game 등 클릭 이벤트가 필요한 메뉴 버튼
Progress Bar: 체력 게이지나 로딩 게이지 등을 시각적으로 표시할 때

점수, 시간, 레벨 표시를 위한 UI Widget 디자인

Canvas Panel

Palette → Panel → Canvas Panel
모든 UI 요소를 포함할 수 있는 큰 도화지 같은 역할
UI 요소들을 자유롭게 배치할 수 있는 가장 기본적인 레이아웃 패널

1920 x 1080 (16:9) 사이즈로 설정을 위해 21.5-24” monitor를 선택

원하는 Font 에셋 만들기

언리얼엔진에서는 기본적으로 Roboto 폰트 스타일만은 제공

폰트 스타일을 적용하기 위해서는 콘텐츠 폴더에 Font 를 import 해야함

원하는 폰트 파일 다운 (.ttf / .otf 확장자를 가진 폰트 파일)

Contents - UI - Fonts 폴더 만들기 → 폴더 에서 마우스 우클릭 → Import to /Game/UI/Fonts 클릭 후

→ .ttf , .otf 폰트 파일을 선택 → 언리얼 엔진 내로 임포트가 진행

임포트가 완료되면, 콘텐츠 브라우저에 새로운 폰트 에셋이 생김

생성된 Font Asset 을 Font Family 를 지정할 때 이 에셋을 적용할 수 있음

2. HUD Widget을 생성해 화면에 표시하기

Widget (HUD나 UI 요소)은 보통 PlayerController에서 구현

Widget이 플레이어의 입력과 상호작용하며 화면에 표시되는 요소이기 때문임

SpartaPlayerController.h

SpartaPlayerController.cpp

SpartaPlayerController → HUD Widget 표시 로직을 넣기

ASpartaPlayerController.h → TSubclassOf<UUserWidget> 변수를 선언

partaPlayerController.cpp 의 BeginPlay() 에 EnhancedInput 설정 직후 HUD 생성 로직을 이어서 작성

CreateWidget 이 작동하려면 UMG 모듈이 빌드 설정에 추가되어 있어야 함

UMG 모듈을 추가하기

PublicDependencyModuleNames.

프로젝트에 사용되는 공개된 종속 모듈

필수적으로 사용하는 엔진 기능

Core : 코어 엔진의 기본 기능
CoreUObject : 리플렉션 시스템, 가비지 컬렉터
Engine : 게임 엔진의 주요 기능
InputCore : 입력 시스템
EnhancedInput : 기존 방식보다 유연하고 강력한 입력 처리 시스템

추가된 모듈

SpartaProject.Build.cs

HUD Widget 테스트하기

BP_SpartaPlayerController 디폴트 블루프린트 or 게임 모드 설정에서 HUDWidgetClass에 WBP_HUD 를 지정

New Editor Window를 선택

에디터 상단의 Play 드롭다운 메뉴 클릭 → Advanced Settings 선택

Advanced Settings

게임 뷰포트 세팅을 HUD와 동일하게 1920x1080 사이즈로 수정

3. HUD 위젯과 GameState 데이터 연동하기

GameState에서 점수 데이터 바인딩하기

언리얼 에디터 → WBP_HUD (Widget Blueprint)

Details 패널 → Text 속성 → Bind 버튼 → Create Binding 선택

Binding 방식

직관적이긴하나, 매 프레임마다 틱 함수를 호출하기 때문에 UI가 복잡할 경우 과부하가 올 수 있음

SetText 방식으로 위젯 갱신하기

SpartaPlayerController.h / .cpp

SpartaPlayerController.h

SpartaPlayerController.cpp

SpartaGameState.h / .cpp

SpartaGameState.h

SpartaGameState.cpp

26.06.22 TIL / C++, Unreal Engine 3D 게임 개발 챕터3 정리

jh009 — Mon, 22 Jun 2026 20:48:55 +0900

오늘

C++와 Unreal Engine으로 3D 게임 개발 챕터3 정리 끝

https://jh009.tistory.com/77

C++와 Unreal Engine으로 3D 게임 개발 3-3

3-3. 아이템 스폰 및 레벨 데이터 관리하기 레벨 셋팅하기 BasicLevel, Intermediate, Level Advanced Level 순서로 난이도에 따라 맵의 크기가 작아짐스폰 영역(Spawn Volume) 설정 방법가장 직관적이고 효율적으

jh009.tistory.com

https://jh009.tistory.com/78

C++와 Unreal Engine으로 3D 게임 개발 3-4

3-4. 캐릭터 체력 및 점수 관리 시스템 구현하기 1. 캐릭터 체력 시스템 구현하기 캐릭터 클래스에 체력 변수 및 함수 선언 PlayerState를 쓰지 않는 이유주로 멀티플레이 환경에서 각 플레이어 간 데

jh009.tistory.com

https://jh009.tistory.com/79

C++와 Unreal Engine으로 3D 게임 개발 3-5

3-5. 게임 루프 설계를 통한 게임 흐름 제어하기1. GameState를 이용한 게임 루프 구현 언리얼 엔진에서 게임 루프나 전역 상태를 관리할 때 대표적으로 고려되는 클래스 GameState, GameMode GameMode를 쓰

jh009.tistory.com

챕터 4 정리 이후 바로 개인과제 진행할 예정

회고

C++ 코드를 활용하여 진행되는 강의라서 이해하는 데 시간이 걸렸다.

30일에 과제 제출이기 때문에 내일까지 다 듣고 과제를 시작할 예정이다.

요새 강의를 듣느라 AI 문제풀이를 소홀히 한 것 같다. 과제를 빠르게 끝내고 문제풀이와 복습도 진행해야겠다.

C++와 Unreal Engine으로 3D 게임 개발 3-5

jh009 — Mon, 22 Jun 2026 12:13:38 +0900

3-5. 게임 루프 설계를 통한 게임 흐름 제어하기

1. GameState를 이용한 게임 루프 구현

언리얼 엔진에서 게임 루프나 전역 상태를 관리할 때 대표적으로 고려되는 클래스 GameState, GameMode

GameMode를 쓰는 이유

서버 전용 로직
게임 규칙 (팀 배정, 승패 조건, 플레이어 스폰 등)을 서버에서 제어하는 데 사용
클라이언트는 GameMode에 직접 접근 X
클라이언트도 알아야 하는 정보 (예시: 남은 시간, 현재 점수 등)를 GameMode에만 두면 복잡해짐

멀티플레이를 고려할 때 많이 사용하는 방식

중요 규칙 로직 → GameMode

서버-클라이언트가 공통으로 알아야 하는 상태 → GameState

GameState를 쓰는 이유

게임 전반에 걸쳐 모든 플레이어가 공유해야 하는 상태를 담는 클래스
전역 상태가 필요할 경우 GameState를 활용
GameState 객체는 게임이 시작될 때 서버에서 생성
클라이언트는 이를 복제 받아서 똑같은 정보를 읽을 수 있음 → 서버와 클라이언트 모두 동일한 정보를 가지게 됨

SpawnVolume 클래스 스폰 데이터 반환 수정

스폰된 아이템의 정보 (코인이 맞는지, 혹은 다른 아이템인지)를 추후 GameState에서 카운팅을 하게 해야함

기존: 스폰 함수가 void를 반환

수정: 스폰 함수가 스폰된 AActor*를 반환해야됨

SpawnRandomItem() 이 스폰된 액터 포인터를 반환하도록 수정, 그 액터가 코인인지 확인할 수 있게 만들기

SpawnVolume.h

SpawnVolume.cpp

GameState 기반의 게임 루프 구현

GameStateBase를 상속한 SpartaGameStateBase는 삭제, GameState를 상속한 SpartaGameState를 생성

→ GameMode 버전과의 일관성을 위함

SpartaGameStateBase.h 와 cpp 에 있는 내용을 SpartaGameState에 복붙 후 수정
파일에서 SpartaGameStateBase.h 와 cpp 삭제

SpartaGameState.h

SpartaGameState.cpp

맵 전환 (OpenLevel) 시 주의

UGameplayStatics::OpenLevel 호출 → 지금 월드가 제거 → 새로운 맵이 로드 → BeginPlay() 다시 실행

이때 GameState도 새로 생성되기 때문에, 이전 레벨에서 유지하던 변수가 모두 초기화될 수 있음

로직 함수

BeginPlay(): 게임 시작 시 StartLevel() 호출

StartLevel():

코인 개수들 초기화 (SpawnedCoinCount=0, CollectedCoinCount=0)
스폰 볼륨들을 찾아서 40개 아이템 스폰(반복)
- 만약 SpawnRandomItem()이 ACoinItem을 반환하면 SpawnedCoinCount++
30초 타이머 설정 (OnLevelTimeUp 호출)

OnLevelTimeUp(): 30초가 만료되면 레벨 종료(EndLevel())
OnCoinCollected(): 코인 아이템을 먹을 때마다 호출
- CollectedCoinCount++
- CollectedCoinCount >= SpawnedCoinCount 이면, 즉시 EndLevel()
EndLevel()
1. 현재 레벨 타이머 정리
2. CurrentLevelIndex++
3. 만약 CurrentLevelIndex >= MaxLevels 이면 OnGameOver()
  - 아니면 다음 레벨 StartLevel()
OnGameOver()
- GameOver 로그 출력 (혹은 UI 호출 등)

코인 아이템 점수 획득 로직 수정

CoinItem → 플레이어가 닿았을 때 (ActivateItem) 점수를 획득하고 자기 자신을 제거하는 구조

여기서 추가로 코인을 하나 더 먹었다고 GameState에게 알려야 함

// CoinItem.cpp
#include "CoinItem.h"
#include "Engine/World.h"
#include "SpartaGameState.h"

ACoinItem::ACoinItem()
{
		PointValue = 0;
		ItemType = "DefaultCoin";
}

void ACoinItem::ActivateItem(AActor* Activator)
{
	if (Activator && Activator->ActorHasTag("Player"))
	{
		if (UWorld* World = GetWorld())
		{
			if (ASpartaGameState* GameState = World->GetGameState<ASpartaGameState>())
			{
				GameState->AddScore(PointValue);
				// 추가
				GameState->OnCoinCollected();
			}
		}
		
		DestroyItem();
	}
}

2. Game Instance를 활용한 데이터 유지하기

레벨 전환 시 맵 내에서 생성된 대부분의 객체가 처음부터 다시 생성이 됨

이전 레벨에서 획득한 점수, 플레이어 상태 등을 모든 레벨에 걸쳐 유지하고 싶을 때 쓰는 방법

Game Instance
- 프로젝트가 시작될 때부터 애플리케이션이 완전히 종료될 때까지 유일하게 계속 살아있는 객체
- 맵이 전환되어도 파괴 X, 여기서 전역 데이터를 유지 가능
Seamless Travel
- 멀티플레이 환경에서 주로 사용되는 레벨 전환 방식
- GameState, PlayerController 등을 파괴하지 않고 그대로 다음 맵으로 넘어가는 기능
- 대부분의 객체를 유지할 수 있지만, 설정과 로직이 조금 더 복잡함
- 싱글 플레이 전용 간단 프로젝트라면 GameInstance 를 사용하기 쉬움

Game Instance 생성 및 변수 선언

C++ Class → Game Instance 생성

SpartaGameInstance.h

SpartaGameInstance.cpp

인스턴스 값을 기존에 스테이트에 추가

// SpartaGameState.cpp

#include "SpartaGameInstance.h" // 추가

// 삭제
// Score += Amount;                    
// UE_LOG(LogTemp, Warning, TEXT("Score: %d"), Score); 

void ASpartaGameState::AddScore(int32 Amount)
{
	// 추가
	if (UGameInstance* GameUnstance = GetGameInstance())
    {
    	USpartaGameInstance* SpartaGameInstance = Cast<USpartaGameInstance>(GameInstance);
        if(SpartaGameInstance)
        {
        	SpartaGameInstance->AddToScore(Amount);
        }
    }
}

void ASpartaGameState::StartLevel()
// CurrentLevelIndex 추가
{
	if (UGameInstance* GameUnstance = GetGameInstance())
    {
    	USpartaGameInstance* SpartaGameInstance = Cast<USpartaGameInstance>(GameInstance);
        if(SpartaGameInstance)
        {
        	CurrentLevelIndex = SpartaGameInstance->CurrentLevelIndex;
        }
    }
.
.
.
void ASpartaGameState::EndLevel()
{		
	GetWorldTimerManager().ClearTimer(LevelTimerHandle);
	
    // 추가 및 수정
	if (UGameInstance* GameUnstance = GetGameInstance())
    {
    	USpartaGameInstance* SpartaGameInstance = Cast<USpartaGameInstance>(GameInstance);
        if(SpartaGameInstance)
        {
        	AddScore(Score);
            CurrentLevelIndex++;
        	SpartaGameInstance->CurrentLevelIndex = CurrentLevelIndex
        }
    }

	if (CurrentLevelIndex >= MaxLevels)
	{
		OnGameOver();
		return;
	}
		
	if (LevelMapNames.IsValidIndex(CurrentLevelIndex))
	{
		UGamePlayStatics::OpenLevel(GetWorld(), LevelMapNames[CurrentLevelIndex]);
	}
	else
	{
		OnGameOver();
	}
}

빌드 이후

BP_SpartaGameInstance 생성

Project Settings → Maps & Modes → 맨 아래 Game Instance → BP_SpartaGameInstance 선택

전체 게임 루프 요약

게임 실행
- GameInstance 생성, GameMode/GameState 생성, 첫 레벨 로드
BeginPlay()
- ASpartaGameState::BeginPlay() → StartLevel()
- 스폰 볼륨(SpawnVolume)에서 40개 아이템 스폰
- 코인 개수 추적(SpawnedCoinCount)
- 30초 타이머 시작
플레이어가 코인 획득
- CoinItem::ActivateItem()에서 GameState->AddScore(), OnCoinCollected()
- 모든 코인을 모으면 즉시 EndLevel()
레벨 종료
- EndLevel()에서 CurrentLevelIndex++
- 남은 레벨이 있으면 UGameplayStatics::OpenLevel(...)로 다음 맵 로드
- 더 이상 레벨이 없으면 OnGameOver()
다음 맵 로드 시
- 새로운 GameState가 생성 → 다시 BeginPlay() → StartLevel()
- 이전 레벨에서 유지하고 싶은 정보는 GameInstance나 “Seamless Travel” 등을 통해 별도로 관리해야 함
Game Over
- 로그 출력 (추후 UI 표시로 전환)

C++와 Unreal Engine으로 3D 게임 개발 3-4

jh009 — Sun, 21 Jun 2026 20:13:36 +0900

3-4. 캐릭터 체력 및 점수 관리 시스템 구현하기

1. 캐릭터 체력 시스템 구현하기

캐릭터 클래스에 체력 변수 및 함수 선언

PlayerState를 쓰지 않는 이유

주로 멀티플레이 환경에서 각 플레이어 간 데이터 동기화를 위해 사용
싱글 플레이 게임에서는 동기화가 필요 없음

캐릭터 클래스에 체력 관리 로직 추가

싱글 플레이 환경을 가정하여, 플레이어 캐릭터를 담당하는 SpartaCharacter 클래스에 체력 관리용 변수를 선언

MaxHealth: 캐릭터의 최대 체력
Health: 캐릭터의 현재 체력
TakeDamage(): 데미지를 받았을 때 호출되는 함수, 내부에서 체력을 감소시키는 로직을 처리
AddHealth(): 아이템 등을 통해 체력을 회복할 때 호출하는 함수, 내부에서 체력을 회복
OnDeath(): 체력이 0 이하가 되었을 때 호출되는 사망 처리 함수

SpartaCharacter.h

데미지 및 회복 처리

AddHealth(float Amount)

체력을 일정 양만큼 회복
FMath::Clamp를 통해 최대 체력을 초과하지 않도록 제한

TakeDamage(...)

언리얼 엔진의 기본 데미지 시스템을 사용하는 대표적인 함수
DamageAmount: 데미지 값
ActualDamage: 캐릭터가 입는 데미지 값 (예시: 데미지 30 - 방어력 20 = 10)
EventInstigator: 데미지를 유발한 주체(Controller)
DamageCauser: 데미지를 직접 발생시킨 오브젝트(총알, 폭발물 등)
반환값: 실제 적용된 데미지(기본 로직에서는 DamageAmount와 동일한 경우가 많지만, 게임 상황에 따라 감소 또는 증폭 등을 처리할 수도 있음)

OnDeath()

체력이 0 이하로 떨어졌을 때 사망 로직을 처리하는 함수
입력 비활성화, Ragdoll 적용, 사망 애니메이션 재생 등을 수행

SpartaCharacter.cpp

지뢰 아이템 데미지 함수 수정

MineItem 이 폭발할 때, 주변 액터에게 데미지를 주려면 UGameplayStatics::ApplyDamage 함수를 호출

해당 액터의 TakeDamage()가 실행되도록 하면 됨

ApplyDamage()

대상 Actor 가 존재하는지 확인
대상 액터의 TakeDamage() 함수를 호출
DamageType 은 여러 가지 파생 클래스를 만들어 물리/화염/독 등 다양한 데미지 유형을 정의할 수 있음 (지금은 기본값 사용)

지뢰는 독립적으로 스폰된 뒤 폭발하므로 EventInstigator를 nullptr로 둡니다.

멀티플레이에서 “누가 지뢰를 설치했느냐” 를 추적하려면, 생성 시점에 Instigator 나 Controller 정보를 넣어줄 수도 있음

MineItem.cpp

힐링 아이템 체력 회복 함수 수정

HealingItem → 플레이어를 회복

AddHealth() 함수를 직접 호출해 체력을 증가

ActorHasTag("Player") 로 플레이어인지 판별하는 단순 로직

캐릭터를 구분하는 더 안전한 방법

(예: Cast<ASpartaCharacter>(Activator)) 을 쓰거나, Collision 채널을 이용하는 식으로도 바꿀 수 있음

HealingItem.cpp

2. 점수 관리 시스템 구현하기

GameMode와 GameState의 연계 이해

언리얼 엔진에서의 GameMode, GameState

→ 게임의 전역 정보를 유지, 필요할 경우 멀티플레이어 환경에서 해당 정보를 서버와 클라이언트 간에 동기화하는 역할

GameMode

게임의 규칙을 정의하고 관리
어떤 캐릭터를 스폰할지, 플레이어가 사망했을 때 어떻게 처리할지를 결정
멀티플레이에서는 서버 전용으로 동작 (클라이언트에는 존재하지 않음)

GameState

게임 플레이 전반에서 공유되어야 하는 전역 상태를 저장
GameState는 기본적으로 레벨당 1개가 존재
전역 데이터 관리용으로 적합 (엔진 내부에서 데이터 동기화를 고려해 설계되었음)
점수, 남은 시간, 현재 게임 단계(Phase), 스폰된 오브젝트의 총 개수 등을 저장
멀티플레이에서는 서버가 관리하고, 클라이언트는 이를 자동으로 동기화 받아볼 수 있음

싱글 플레이에서의 GameState

전역적으로 공유해야 할 정보를 한 군데서 관리하면 유지보수가 더 편함

아이템 스폰 개수, 현재 게임 진행도 등과 같은 데이터를 GameState 에서 일괄 관리할 수 있기 때문임

GameState에 점수 데이터 및 함수 추가

전역 점수를 GameState 에 저장 후, 점수를 획득할 때마다 AddScore()를 호출하여 점수가 증가하도록 구현

GameStateBase - 싱글플레이, 복잡하지 않은 게임

GameState - 멀티플레이

C++ Class → GameStateBase 선택 → 이름 설정 (SpartaGameStateBase)

SpartaGameState.h

Score: 현재 누적된 점수
AddScore(int32 Amount): 점수를 Amount만큼 증가, 최대 점수 제한, 점수 획득 사운드 재생 등을 추가할 수도 있음
GetScore(): 현 점수 반환, 블루프린트에서 UI를 만들 때도 이 함수를 이용해 쉽게 점수를 가져올 수 있음

SpartaGameState.cpp

GameMode와 GameState 연동

기존에 만들었던 GameMode 클래스에서 GameStateClass 멤버를 SpartaGameState로 설정

SpartaGameMode.cpp

SpartaGameStateBase에 대한 C++ 코드가 컴파일 → 언리얼 에디터에서 해당 클래스를 인식하게 됨

SpartaGameStateBase를 더 확장하거나 블루프린트 비주얼 스크립팅을 사용하기 위해,

C++ 클래스를 부모로 하는 블루프린트(BP_SpartaGameStateBase)를 만들어서 사용

Project Settings 적용

Edit → Project Settings → Maps & Modes → Default GameMode

SpartaGameModeBase 또는 그 블루프린트 클래스로 설정

Game State Class → BP_SpartaGameStateBase(또는 SpartaGameStateBase) 로 설정

→ 전역적으로 이 설정이 적용

World Settings에서 설정 (레벨별로 오버라이드 가능)

코인 아이템 점수 획득 함수 수정

GetWorld()->GetGameState<ASpartaGameStateBase>() 로 게임 스테이트를 가져오기

AddScore(PointValue) 함수를 호출해 점수를 올림

PointValue(int32) → 코인 아이템이 제공하는 점수량, ACoinItem의 멤버 변수로 관리

플레이어가 코인을 획득하면, 전역적으로 관리되는 GameState에서 점수가 증가

코인은 사라져서 한 번만 획득되도록 처리

CoinItem.cpp