blog13869 님의 블로그

8/4 TIL

blog13869 — Tue, 4 Aug 2026 20:24:52 +0900

[ 강의 1 - 6 NetRole ]

< 매크로를 통한 NetRole 출력 >

새 C++ 클래스 > Pawn 부모 클래스 > “CXPawn”
Path: `Player`
`BP_GameModeBase > Details > Default Pawn Class`에 `CXPawn` 지정

< CFM.h >

// 현재 할당돼있는 NetRole을 출력해서 확인하게 해주는 함수
static FString GetRoleString(const AActor* InActor)
{
    FString RoleString = TEXT("None");

    if (IsValid(InActor) == true)
    {
       FString LocalRoleString = UEnum::GetValueAsString(TEXT("Engine.ENetRole"), InActor->GetLocalRole());
       FString RemoteRoleString = UEnum::GetValueAsString(TEXT("Engine.ENetRole"), InActor->GetRemoteRole());
       
       RoleString = FString::Printf(TEXT("%s / %s"), *LocalRoleString, *RemoteRoleString);
    }

    return RoleString;
}

< CFMPawn.h >

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Pawn.h"
#include "CFMPawn.generated.h"

UCLASS()
class CFM_API ACFMPawn : public APawn
{
    GENERATED_BODY()
    
protected:
    
    // 게임이 시작됐을 때 바로 호출
    virtual void BeginPlay() override;

    //빙의됐을 때 호출
    virtual void PossessedBy(AController* NewController) override;

};

< CFMPawn.cpp >

#include "CFMPawn.h"
#include "CFM.h"


void ACFMPawn::BeginPlay()
{
    Super::BeginPlay();
    
    // 시작되자마자 현재 적용돼있는 NetRole 출력
    FString NetRoleString = CFMFunctionLibrary::GetRoleString(this);
    FString CombinedString = FString::Printf(TEXT("CXPawn::BeginPlay() %s [%s]"), *CFMFunctionLibrary::GetNetModeString(this), *NetRoleString);
    CFMFunctionLibrary::MyPrintString(this, CombinedString, 10.f);
}

void ACFMPawn::PossessedBy(AController* NewController)
{
    Super::PossessedBy(NewController);
    
    // 게임 시작 한 뒤 컨트롤러에 Pawn이 할당됐을 때 NetRole 출력
    FString NetRoleString = CFMFunctionLibrary::GetRoleString(this);
    FString CombinedString = FString::Printf(TEXT("CXPawn::PossessedBy() %s [%s]"), *CFMFunctionLibrary::GetNetModeString(this), *NetRoleString);
    CFMFunctionLibrary::MyPrintString(this, CombinedString, 10.f);
}

BP_GameModeBase > Details > Default Pawn Class에 CXPawn을 지정

< 실행 시 나오는 로그 확인 >

시작 시 Simulated Proxy : 피동기화 상태 ( SetOwner 가 아직 X )
PlayerController할당 : Autonomous Proxy : 서버로부터 데이터를 수신 받아서 동기화도 되면서, 서버로 송신도 가능

< NetRole을 활용하여 정의된 중요 함수들 >

< AActor::HasAuthority() >

입력 관련 로직이나 UI는 Autonomous Proxy에서 수행
AController::IsLocalController() 와 APawn::IsLocallyControlled() 함수가 제공

< 각 액터에 따른 특징 >

GameMode 는 HasAuthority() 함수를 호출할 필요 X
Pawn 은 Authority, Autonomous Proxy, Simulated Proxy가 혼재
UI 관련 로직은 클라이언트에서만 수행

< 로컬 롤과 리모트 롤로 분류한 이유 >

만약 로컬 롤만 있었다면 분간하기가 어려웠을 케이스들이 존재
서버에 접속한 플레이어의 캐릭터 A와 서버에서 스폰 된 캐릭터 B가 있다고 가정한다면
A와 B의 로컬 롤은 *Authority*

로컬 롤만으로는 서버에 접속한 플레이어의 캐릭터인지, 서버에서 스폰된건지 구분이 불가능
여기서 만약 리모트 롤까지 알게된다면, 서버에 접속한 플레이어의 캐릭터는 **Autonomus Proxy**이고,
서버에서 스폰된 캐릭터는 `None`이므로 구분이 가능

구분이 가능해야 서버에서 호출되고 오너 클라이언트에서 실행될 RPC를 구현이 가능
멀티플레이에서 각 액터들을 좀 더 정확하게 분류하게 위해 둘로 분류

[ 강의 2-1. Remote Procedure Call 기초 ]

< RPC(Remote Procedure Call) >

호출하는 PC와 실행하는 PC가 달라도 되게끔 해주는 통신 기법
게임에 큰 영향을 끼치지 않는 일시적인 효과들에 사용하는 편
주로 코스메틱(사운드, 파티클 등)에 사용

< Call과 Invoke >

< Call >

정적인 의미
컴파일 타임에 어떤 함수인지, 호출하는 곳과 실행하는 곳이 결정
지금까지 정의했던 일반적인 전역 함수와 멤버 함수가 이에 해당
직접적으로 함수를 호출하고 실행 (Direct)

< Invoke >

동적인 의미
런타임에 어떤 함수인지, 호출하는 곳과 실행하는 곳이 결정
함수 포인터, 동적 바인딩, RPC 같은 개념들이 이에 해당
간접적으로 함수를 호출하고 실행 (Indirect)

RPC도 마찬가지로 "RPC를 Invoke"라고 표현

< Actor Ownership >

트워크 멀티플레이가 적용되려면, 액터는 서버에서 스폰되고 `bReplicates`가 `true`여야 가능
서버에서 스폰된 후 `SetOwner(PlayerController)` 함수를 호출해야 Client-Owned Actor가 할당

Client-Owned Actor : PlayerController == Local PlayerController
ex) 내 플레이어 캐릭터
Owned by different client : PlayerController !== Local PlayerController
ex) 내 화면에 보이는 친구의 플레이어 캐릭터
Server-Owned Actor :서버에서 스폰되었지만 SetOwner() 함수 호출 X
ex) 보물상자 액터
Unowned Actor == Server-Owned Actor

< NetMulticast, Server, Client 키워드 >

`UFUNCTION()` 매크로와 함께 사용되는 키워드
키워드 : 해당 원격 PC에서 RPC를 실행시켜 달라는 요청
실제로 실행될지는 표를 통해 판단

NetMulticast : 서버를 포함한 모든 클라이언트에서 해당 RPC를 실행을 요청
Server : 서버에서 해당 RPC를 실행을 요청
Client : 클라이언트에서 해당 RPC를 실행을 요청

NetMulticast RPC

Server RPC

Client RPC

<자주 쓰이는 케이스 >

< Server 키워드 >

RPC가 클라이언트에서 호출되고 서버에서 실행되어야 하는 경우
ClientConnection이 소유하고 있는 액터(Client-Owned)에서 RPC가 호출
_Validate() 함수에서 RPC를 실행할지 말지 결정

< NetMulticast 키워드 >

RPC가 서버와 모든 클라이언트에서 실행되어야 하는 경우
서버에서 호출
부하가 심하므로, 빈번하게 호출되게끔 코드를 작성하는 건 권장 X
ex) Tick() 함수 내에서 NetMulticast RPC 호출

< Client 키워드 >

RPC가 서버에서 호출되고 클라이언트에서 실행되어야 하는 경우
서버에서 호출

< WithValidation >

UFUNCTION() 매크로와 함께 사용되는 키워드
서버에서 실행되는 RPC의 경우에 해당 키워드를 작성하는 것이 권장
이 키워드가 붙은 RPC를 구현 할때는 _Implementation() 함수와 _Validate() 함수로 분류
_Validate() 함수는 해당 RPC가 서버에서 실제로 실행을 결정
서버 실행 로직은 무조건적으로 신뢰되기 때문에, 위변조를 막기 위한 방어막 역할

< Unreliable VS Reliable >

UFUNCTION() 매크로와 함께 사용되는 키워드
RPC는 기본적으로 **Unreliable** 키워드를 기준으로 동작
아무것도 안쓰면 Unreliable
Unreliable은 원격 PC에서 무조건 실행되리라는 보장 X
반면, 원격 PC에서 무조건 실행되어야 하는 로직이라면 Reliable 키워드를 작성
Unreliable 의 활용 예시 : 코스메틱(이펙트, 사운드 등)처럼 게임에 큰 영향이 없는 로직
Reliable 의 활용 예시 : 충돌, 데미지, 스폰처럼 게임에 큰 영향을 끼치는 로직

[ 강의 2 - 2 : 멀티플레이 채팅 구현 ]

< 내가 작성한 채팅 메세지가 다른 PC의 화면에도 나오게 하는 방법 >

< 데디케이티드 서버 구조 >

클라이언트와 클라이언트 간의 통신은 불가능
서버와 클라이언트 간의 통신만 가능
내가 작성한 채팅 메시지는 일단 서버로 전송
서버는 전송 받은 메세지를 다시 클라이언트들에게 전송

< 멀티플레이 채팅 구현 >

< CFMPlayerController.h >

//서버에서 출력한 채팅을 클라이언트에서 받는 함수 (Client RPC) , 채팅메세지가 날아가지 않게 끔 Reliable 키워드 추가
UFUNCTION(Client, Reliable)
void ClientRPCPrintChatMessageString(const FString& InChatMessageString);

// 채팅을 서버로 보내기 위한 함수 (Server RPC), 채팅메세지가 날아가지 않게 끔 Reliable 키워드 추가
UFUNCTION(Server, Reliable)
void ServerRPCPrintChatMessageString(const FString& InChatMessageString);

< CFMPlayerController.cpp >

#include "EngineUtils.h" // TActorIterator 사용 용도

void ACFMPlayerController::SetChatMessageString(const FString& InChatMessageString)
{
    ChatMessageString = InChatMessageString;
    //PrintChatMessageString(ChatMessageString);
    // 기존 PrintChatMessageString 주석 처리 후 Controller가 할당 돼있다면 Server에 채팅 보내는 함수로 변경
    if (IsLocalController() == true)
    {
       ServerRPCPrintChatMessageString(InChatMessageString);     
    }
}

// RPC를 만들 때  Implementation 을 붙히는 게 국룰 문법
void ACFMPlayerController::ServerRPCPrintChatMessageString_Implementation(const FString& InChatMessageString)
{
    // 서버에서 플레이어 컨트롤러를 확인
    for (TActorIterator<ACFMPlayerController> It(GetWorld()); It; ++It)
    { 
       // 확인한 플레이어 컨트롤러들이 유효하면 실행
       ACFMPlayerController* CXPlayerController = *It;
       if (IsValid(CXPlayerController) == true)
       {
          // 해당 플레이어컨트롤러에 ClientRPCPrintChatMessageString함수를 통해 해당 PC에서 채팅 출력
          CXPlayerController->ClientRPCPrintChatMessageString(InChatMessageString);
       }
    }
}

void ACFMPlayerController::ClientRPCPrintChatMessageString_Implementation(const FString& InChatMessageString)
{
    // 출력 하는 함수만 추가 (ServerRPC 함수 쪽에서 호출용)
    PrintChatMessageString(InChatMessageString); 
}

< Client RPC 대신에 NetMulticast RPC를 사용한다면? >

작동 X
PlayerController는 내 PC와 서버 PC에만 존재하기 때문에 NetMulticast RPC로 구현하면 내 PC와 서버 PC에만 채팅이 출력

< NetMulticast RPC를 통한 서버 접속 알리기 >

새 C++ 클래스 > GameStateBase 부모 클래스 > “CXGameStateBase”
Path: `Game`
Content Browser > Content > ChatX > Blueprint > Game
새 Blueprint 클래스 > CXGameStateBase 부모 클래스 > “BP_GameStateBase”
BP_GameModeBase > Details > Game State Class에 BP_GameStateBase 지정

< CFMGameStateBase.h >

public:
    
    // MulticastRPC 를 사용해서 누군가 접속(로그인) 했을 때 알려주는(TEXT호출) 함수
    UFUNCTION(NetMulticast, Reliable)
    void MulticastRPCBroadcastLoginMessage(const FString& InNameString = FString(TEXT("XXXXXXX")));

< CFMGameStateBase.cpp >

#include "Game/CFMGameStateBase.h"
#include "Kismet/GameplayStatics.h"
#include "Player/CFMPlayerController.h"



void ACFMGameStateBase::MulticastRPCBroadcastLoginMessage_Implementation(const FString& InNameString)
{
    // HasAuthority() == false = 서버가 아니라면 = 클라이언트라면
    if (HasAuthority() == false)
    {
       //  0번 컨트롤러 (LocalPlayerController)를 가져오고
       APlayerController* PC = UGameplayStatics::GetPlayerController(GetWorld(), 0);
       if (IsValid(PC) == true)
       {
          // 로컬플레이어가 유요 하다면 NotificationString 으로 게임에 접속했다는 문구 출력
          ACFMPlayerController* CFMPC = Cast<ACFMPlayerController>(PC);
          if (IsValid(CFMPC) == true)
          {
             FString NotificationString = InNameString + TEXT(" has joined the game.");
             CFMPC->PrintChatMessageString(NotificationString);
          }
       }

< CFMGameStateBase.h >

public:

// 다른 플레이어 (NewPlayer)가 로그인 할 때 실행되는 함수
virtual void OnPostLogin(AController* NewPlayer) override;

< CFMGameStateBase.h >

#include "Game/CFMGameModeBase.h"
#include "Game/CFMGameStateBase.h"



void ACFMGameModeBase::OnPostLogin(AController* NewPlayer)
{
    // 누군가 접속 할 때 마다
    Super::OnPostLogin(NewPlayer);

    // 접속한 NewPlayer의 GameStateBase를 가져오고 
    ACFMGameStateBase* CFMGameStateBase =  GetGameState<ACFMGameStateBase>();
    // GameStateBase 가 유효하다면 MulticastRPC 로그인 메세지 출력 함수 호출
    if (IsValid(CFMGameStateBase) == true)
    {
       CFMGameStateBase->MulticastRPCBroadcastLoginMessage(TEXT("XXXXXXX"));
    }
}

7/31 TIL

blog13869 — Fri, 31 Jul 2026 21:03:04 +0900

[ CH4_Unreal Engine 멀티플레이어 게임 개발 ]

[강의 1-3. 서버의 종류와 데디케이티드 서버]

< 서버의 종류와 구조 >

P2P Server(Peer to Peer Server)
ㄴ 각각의 컴퓨터가 클라이언트이자 서버인 구조

Listen Server
ㄴ 클라이언트이자 서버인 방장(Host)이 있고, 나머지 참가자(Guest)는 모두 클라이언트 역할만 맡는 형태
P2P의 일종

Dedicated Server
ㄴ 서버를 담당하는 컴퓨터가 별도로 존재

서버 - 클라이언트 구조

< Dedicated Server의 실행 흐름도 >

1. PIE를 했거나, Server.exe를 실행하는 식으로 서버 프로세스 실행.

실행할 때 Open {Level이름}?Listen 명령어가 인자로 전달
해당 Level을 열고 Socket이 생성되며 다른 PC가 접속 가능하게끔 설정
Listen 명령어가 없다면 싱글플레이

2. Level의 정보를 토대로 GameMode와 GameState 액터를 생성

Level의 WorldSettings 속성이 존재하고 WorldSettings에는 GameMode와 GameState 정보가 할당
이를 통해 GameMode와 GameState 액터를 생성
중요한 것은 GameMode 액터는 전체 컴퓨터에서 딱 한 곳(Server)에만 존재
그래서 GameMode와 Server를 동일시 설정해도 무방

3. 클라이언트에서 접속 요청

클라이언트는 서버의 IP주소와 포트번호로 접속 시도
서버는 접속 시도하는 클라이언트에게 Level 정보를 전달
클라이언트도 해당 Level을 열고, Level을 여는데 성공했다고 데디 서버에게 알림

4. 접속 성공 시 게임의 정보를 클라이언트에 복제/대입

Level을 여는데 성공한 클라이언트 전용 PlayerState, PlayerController, PlayerCharacter가 서버에 생성
PlayerState, PlayerController, PlayerCharacter 등 이 다시 Client1에 복제
GameState 도 복제

5. 또 다른 클라이언트도 접속 ( 3~4 단계 반복 )

마찬가지로 서버는 접속 시도하는 또 다른 클라이언트에게 Level 정보를 전달
클라이언트도 해당 Level을 열고, Level을 여는데 성공했다고 데디 서버에게 알림
Client2 전용 PlayerState, PlayerController, PlayerCharacter가 서버에 생성
이것이 다시 Client2에 복제
GameState도 복제
이때, 클라이언트 간의 PlayerState와 PlayerCharacter도 복제되면서 서로 존재 확인 가능

※ 다른 클라이언트의 PlayerState와 PlayerCharacter의 정보는 저장하지만

PlayerController는 본인의 클라이언트의 정보만 저장 ※

< 이미지 설명 >

↓

< 서버 - 클라이언트 구조의 중요한 특징 >

클라이언트와 클라이언트 간의 통신이 불가능
오직 서버와 클라이언트 사이의 통신만 가능
RPC나 프로퍼티 레플리케이션에도 영향

[ 강의 1-4. 실습 환경 설정 ]

위젯 객체는 Owning Client에서만 생성
Owning Client를 판별하기 위해서 IsLocalController() 함수를 호출

< PlayerController 의 BeginPlay 함수 안에 작성 >

// Owning Client 인지 확인
if (IsLocalController() == false)
{
    return;
}

< 데디케이티드 서버 환경 설정 >

< Allow Late Joining 체크 >

Add another cliner 버튼으로 클라이언트 추가 가능

< Always on top > (필수 X)

새 클라이언트 화면이 항상 위에 생성

< Multiplayer Options - Launch Seperate Server >

체크 시 서버 따로 생성
체크 해제 시 에디터 화면이 클라이언트이자 서버

< Multiplayer Options - Run Under One Process >

체크하면 같은 프로세스 내라서 공유하는 에셋이 생성
따라서 확실한 멀티플레이 환경이라고 보기엔 무리
성능상의 이점 : 체크하지 않으면 서버와 각 클라이언트들이 다른 프로세스로 분기
추후에 멀티플레이 디버깅 시 체크하고 로깅으로 확인 가능

< “Net Mode”는 “Play as Client”로 설정 >

Net Mode - Play as Client : Dedicated 환경

[ 강의 1-5. NetMode, NetConnection, NetDriver ]

< 정의 >

해당 게임 프로세스가 네트워크 상에서 어떤 역할을 하고 있는지를 의미
싱글(NM_StandAlone) 서버(NM_Listen, NM_DedicatedServer), 클라이언트(NM_Client)

< NetMode의 필요성 >

로직이 서버에서 돌고 있는지 클라이언트에서 돌고 있는지를 확인 할 때 사용
멀티플레이 개발 시에 같은 코드가 여러 PC에서 동작 -> 서버 PC에서, 내 PC에서, 다른 사람의 PC에서 동작

위 사진처럼 구조가 짜여져 있다는 가정 하에

PlayerCharacter :: BeginPlay 함수에 UE_LOG를 작성했다면

ㄴ Server ,C1,C2에 해당돼있는 모든 PlayerCharacter의 UE_LOG가 호출된다

빨간 PlayerController :: BeginPlay 함수에 UE_LOG를 작성했다면

ㄴ Server,C1 의 PlayerController에 UE_LOG가 호출된다

< NetMode 와 NetRole >

NetMode : 월드 단위의 속성값
NetRole : 액터 단위의 속성값

< UWorld::InternalGetNetMode() 함수 살펴보기 >

ENetMode UWorld::InternalGetNetMode() const
{
    if ( NetDriver != NULL )                                      // 넷드라이버가 설정되어 있으면
    {
       const bool bIsClientOnly = IsRunningClientOnly();
       return bIsClientOnly ? NM_Client : NetDriver->GetNetMode(); // 클라 아니면 서버 둘 중 하나다.
    }

    ...
}

// UNetDriver.cpp

ENetMode UNetDriver::GetNetMode() const
{
#if WITH_EDITOR
    if (World && World->WorldType == EWorldType::PIE && IsServer())
    {
       FWorldContext* WorldContext = GEngine->GetWorldContextFromWorld(World);
       if (WorldContext && WorldContext->RunAsDedicated) // 데디로 실행했다면
       {
          return NM_DedicatedServer;                      // 데디 서버 반환.
       }
    }
#endif

    return (IsServer() ? (GIsClient ? NM_ListenServer : NM_DedicatedServer) : NM_Client);
    // 서버인데, 클라이언트로 참여하고 있다? 리슨서버. 서버인데 참여하고 있지 않다? 데디서버.
}

bool UNetDriver::IsServer() const
{
    return ServerConnection == NULL;
    // 클라이언트는 무조건 서버 커넥션을 가지고 있다.
}

< NetConnection >

< 정의 >

다른 PC와의 연결이 발생하면 그에 대응하는 UNetConnection 객체도 생성
서버에 클라이언트가 접속하면 서버에는 ClientConnection 객체가 추가
반대로 클라이언트에는 ServerConnection 객체가 생성
두 PC는 UNetConnection 객체를 통해 통신
UNetDriver는 생성된 UNetConnection 객체를 소유하고 관리
서버 PC에 생성된 UNetDriver는 접속한 클라이언트의 수 만큼 UNetConnection을 관리
클라이언트 PC에 생성된 UNetDriver는 ServerConnection 단 하나만을 관리
서버-클라이언트 구조의 템플릿
NetDriver : 멀티플레이 실행 장치

// UNetDriver.h

...

UCLASS(...)
class UNetDriver : public UObject, public FExec
{
    ...
    
    // 클라이언트 전용 (단일 취급)
    UPROPERTY()
    TObjectPtr<class UNetConnection> ServerConnection;

    // 서버 전용 (복수 취급 (배열))
    UPROPERTY()
    TArray<TObjectPtr<UNetConnection>> ClientConnections;
    
    ...

}

UNetConnection* AActor::GetNetConnection() const
{
    return Owner ? Owner->GetNetConnection() : nullptr;
    // 여기서 오너는 액터/폰/컨트롤러 등등이 해당
    // Owner가 지정되어 있지 않으면 통신 불가
}

class UNetConnection* APawn::GetNetConnection() const
{
    if ( Controller ) // 컨트롤러가 있다면
    {
       return Controller->GetNetConnection(); // 컨트롤러의 GetNetConnection()을 호출.
    }
    return Super::GetNetConnection(); // 없다면 AActor::GetNetConnection() 함수 호출.
}

UNetConnection* APlayerController::GetNetConnection() const
{
    return (Player != NULL) ? NetConnection : NULL;
    // 플레이어가 존재한다면 NetConnection 객체를 반환.
}

< 언리얼에서의 Ownership >

하나의 ClientConnection은 하나의 PlayerController를 소유 -> PlayerController의 Owning Connection은 ClientConnection 와 동일
PlayerController가 빙의하는 폰의 Owner 속성은 해당 PlayerController로 설정
폰에 무기 액터가 생성되고, 무기 액터의 Owner 속성에 해당 폰을 설정 가능
패밀리 : ClientConnection에서부터 무기 액터에 이르는 소유 관계
소유 관계 속에 있는 액터가 본인의 Owning Connection을 얻으려면
AActor::GetNetConnection() 함수를 호출
이 소유 관계가 후에 배울 RPC와 Property Replication과 관련

< NetDriver >

언리얼 네트워크 통신에서 로우레벨 동작들을 관리하는 클래스
싱글플레이에서는 UNetDriver 객체가 생성 X
멀티플레이에서만 UWorld::Listen() 함수를 통해 UNetDriver 객체가 생성
멀티플레이에 참여하는 각 PC마다 UNetDriver 객체가 생성
ex) 컴퓨터 포맷 후 Wifi Driver를 설치하는 것과 유사합니다.

// UWorld.cpp

bool UWorld::Listen( FURL& InURL )
{
#if WITH_SERVER_CODE
    ...

    // Create net driver. 넷드라이버 만드는 부분이 있다~ 정도.
    if (GEngine->CreateNamedNetDriver(this, NAME_GameNetDriver, NAME_GameNetDriver))
    {
       NetDriver = GEngine->FindNamedNetDriver(this, NAME_GameNetDriver);

       ...
    }

    ...
}

[ NetMode에 대한 추가적인 설명 ]

< StandAlone >

게임이 원격 클라이언트의 연결을 허용하지 않는 서버로 실행
커넥션이 없음. 게임에 참여하는 모든 플레이어는 로컬 플레이어
싱글 플레이 및 로컬 플레이 게임에 사용
로컬 플레이어에 맞게 서버 측 로직과 클라이언트측 로직을 모두 실행

< Client >

게임이 네트워크 멀티플레이 세션에서 서버에 연결된 클라이언트로 실행
서버 측 로직을 실행하지 않습니다. 서버로부터 복제된 Proxy를 보여주는 역할

< Listen Server >

게임이 네트워크 멀티플레이어 세션을 호스팅 하는 서버로 실행
원격 클라이언트의 연결을 수락하고 로컬 플레이어를 서버에 직접 배치
즉, 서버 자기 자신도 게임에 직접 참여
이 모드는 캐주얼 협동 및 경쟁 멀티플레이어에 자주 사용

< Dedicated Server >

게임이 네트워크 멀티플레이 세션을 호스팅 하는 서버로 실행
원격 클라이언트의 연결을 허용하지만 로컬 플레이어는 존재 X
따라서 그래픽, 사운드, 입력 및 기타 플레이어 중심 기능이 필요 없으니 삭제
이 모드는 지속적이고 안전한 대규모 멀티플레이어가 필요한 게임에 주로 사용

[ NetMode에 따른 액터 위치 ]

서버에만 존재하는 액터

GameMode

서버와 모든 클라이언트에 존재하는 액터

배경 액터와 Pawn

서버와 클라이언트에만 존재하는 액터

PlayerController , ABP

클라이언트에만 존재하는 언리얼 오브젝트

[ 강의 1-6. NetRole ]

< Authority와 Proxy >

서버에 스폰 된 액터가 가진 NetRole 속성 값은 언제나 Authority
ㄴ 서버에 스폰 된 액터에서 수행될 로직은 “권한을 가지고 있다”를 의미
ㄴ 게임에 중대한 영향을 끼치는 로직은 NetRole이 Authority일 때만 수행하게 설정
NetRole이 Authority인 액터가 클라이언트로 복제되었을 때,
클라이언트에 복제된 액터의 NetRole 속성 값은 Proxy : “허상”
여기서는 중요한 로직을 수행 X

< 로컬 롤과 리모트 롤 >

로컬 롤(Local Role) : 현재 동작하는 컴퓨터에서의 롤

리모트 롤(Remote Role) : 커넥션으로 연결된 반대편 컴퓨터에서의 롤

< NetRole의 종류 >

< None >

레플리케이션 되지 않는 액터
다만, 무조건적이진 않음
ex) LocalRole은 Authority이고 RemoteRole이 None이라면
서버에서 스폰 되고, 클라쪽으로 레플리케이션 되지 않는 액터라고 취급

< Authority >

게임에 중대한 영향을 끼칠 수 있는 권한을 가진 액터
서버에서 스폰된 액터가 LocalRole으로 Authority를 가질 수 있음
ex) GameMode

< Autonomous Proxy >

Authority 액터의 복제본
서버로부터 데이터를 수신 받아서 동기화도 되면서, 서버로 송신도 가능
ex) PlayerController

< Simulated Proxy >

Authority 액터의 복제본
서버로부터 수신 받아서 동기화만 가능
ex) AnotherPlayer 의 PlayerCharacter

7/30 TIL

blog13869 — Thu, 30 Jul 2026 20:50:15 +0900

[ CH4_Unreal Engine 멀티플레이어 게임 개발 ]

팀이 다시 짜여졌고

처음은 개인 과제로 시작을 하게 되었다.

녹화 강의를 통해 공부를 하는 시간이고

배운 내용을 적게 되었다.

프로젝트 이름(CFM : Chapter Four Multi)의 이름을 사용해서

생성하는 모든 파일들의 말머리에 CFM을 붙히는 규칙으로 정하였다.

[ 채팅 프로젝트 생성 ]

< CFMGameModeBase >

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "CFMGameModeBase.generated.h"

/**
 * 
 */
UCLASS()
class CFM_API ACFMGameModeBase : public AGameModeBase
{
    GENERATED_BODY()
    
};

기본적으로 GameMode를 Custom을 할 수 있게 GameModeBase를 상속받아 C++ 파일을 생성하여 작업을 시작

< CFMPlayerController >

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "CFMPlayerController.generated.h"

/**
 * 
 */

class UCFMChatInput;
// 전방 선언으로 헤더 파일에 해당 내용들을 선언해도 문제생기지 않게 작성

UCLASS()
class CFM_API ACFMPlayerController : public APlayerController
{
    GENERATED_BODY()
    
    public:
    
    virtual void BeginPlay() override;
    
    void SetChatMessageString(const FString& InChatMessageString);
    
    void PrintChatMessageString(const FString& InChatMessageString);

    
    
    protected:
    
    UPROPERTY(EditDefaultsOnly)
    TSubclassOf<UCFMChatInput> ChatInputWidgetClass;
    // WBP_ChatInput 과 연결
    
    UPROPERTY()
    TObjectPtr<UCFMChatInput> ChatInputWidgetInstance;
    
    FString ChatMessageString;
    // 채팅 내용
    
};

#include "Player/CFMPlayerController.h"
#include "UI/CFMChatInput.h"
#include "Kismet/KismetSystemLibrary.h"


void ACFMPlayerController::BeginPlay()
{
    Super::BeginPlay();
    
    // 입력 할당
    FInputModeUIOnly InputModeUIOnly;
    SetInputMode(InputModeUIOnly);

    // ChatInputWidgetClass가 변수로 선언 돼있을 때 WBP_ChatInput을 연결
    if (IsValid(ChatInputWidgetClass) == true)
    {
       ChatInputWidgetInstance = CreateWidget<UCFMChatInput>(this, ChatInputWidgetClass);
       if (IsValid(ChatInputWidgetInstance) == true)
       {
          // 입력 내용을 Viewport에 출력할 수 있게 설정
          ChatInputWidgetInstance->AddToViewport();
       }
    }
}

// ChatMessageString을 함수의 인자값으로 대입 후 출력
void ACFMPlayerController::SetChatMessageString(const FString& InChatMessageString)
{
    ChatMessageString = InChatMessageString;
    PrintChatMessageString(ChatMessageString);
}

// 화면에 String을 출력
void ACFMPlayerController::PrintChatMessageString(const FString& InChatMessageString)
{
    UKismetSystemLibrary::PrintString(this, ChatMessageString, true, true, FLinearColor::Red, 5.0f);
}

< CFMChatInput >

#pragma once

#include "CoreMinimal.h"
#include "Blueprint/UserWidget.h"
#include "CFMChatInput.generated.h"

class UEditableTextBox;

UCLASS()
class CFM_API UCFMChatInput : public UUserWidget
{
    GENERATED_BODY()
    
public:
    
    // WBP_ChatInput 의 팔레트 안에 있는 'EditableTextBox_ChatInput' 에 바인딩
    UPROPERTY(meta=(BindWidget))
    TObjectPtr<UEditableTextBox> EditableTextBox_ChatInput;
    
    virtual void NativeConstruct() override;

    virtual void NativeDestruct() override;
    
    
protected:
    
    UFUNCTION()
    void OnChatInputTextCommitted(const FText& Text, ETextCommit::Type CommitMethod);
    
};

#include "UI/CFMChatInput.h"
#include "Components/EditableTextBox.h"
#include "Player/CFMPlayerController.h"




// WBP_ChatInput 의 OnTextCommitted 이벤트와 Delegate로 바인딩 확인/연결
void UCFMChatInput::NativeConstruct()
{
    Super::NativeConstruct();
    if (EditableTextBox_ChatInput->OnTextCommitted.IsAlreadyBound(this, &ThisClass::OnChatInputTextCommitted) == false)
    {
       EditableTextBox_ChatInput->OnTextCommitted.AddDynamic(this, &ThisClass::OnChatInputTextCommitted);    
    }  
}

// WBP_ChatInput 의 OnTextCommitted 이벤트 종료 시 바인딩 해제
void UCFMChatInput::NativeDestruct()
{
    Super::NativeDestruct();
    if (EditableTextBox_ChatInput->OnTextCommitted.IsAlreadyBound(this, &ThisClass::OnChatInputTextCommitted) == true)
    {
       EditableTextBox_ChatInput->OnTextCommitted.RemoveDynamic(this, &ThisClass::OnChatInputTextCommitted);
    }

}


// Enter와 같은 키로 텍스트를 제출 했을 때 GetOwningPlayer 함수를 통해서 제출을 요청한 컴퓨터의 PlayerController를 가져오고
// 유효 했을 때 Cast 후 ChatMessageString 내용을 EditableTextBox_ChatInput 여기에 출력시키는 함수
// 이 후 빈 텍스트(FText())로 내용 지우기
void UCFMChatInput::OnChatInputTextCommitted(const FText& Text, ETextCommit::Type CommitMethod)
{
    if (CommitMethod == ETextCommit::OnEnter)
    {
       APlayerController* OwningPlayerController = GetOwningPlayer();
       if (IsValid(OwningPlayerController) == true)
       {
          ACFMPlayerController* OwningCFMPlayerController = Cast<ACFMPlayerController>(OwningPlayerController);
          if (IsValid(OwningCFMPlayerController) == true)
          {
             OwningCFMPlayerController->SetChatMessageString(Text.ToString());

             EditableTextBox_ChatInput->SetText(FText());
          }
       }
    }
}

[ 스크럼 ]

< 오전 스크럼 >

< 오후 스크럼 >

7/28 TIL

blog13869 — Tue, 28 Jul 2026 21:04:55 +0900

[ 커리어데이 ]

어제 브로셔 템플릿을 작성한 이 후 개인적으로 느낀점과 보완할 점 등 개인 회고를 작성하는 시간을 가졌다.

[ CH3 - 프로젝트 개인 회고 ]

< 내가 맡은 주요 작업 및 기능 >

게임 시작부터 게임이 끝나는 로직을 구체화하고 레벨이 넘어가는 조건, 웨이브를 클리어하는 조건 등 게임의 기반을 다짐
SpawnPortal을 만들어 몬스터를 스폰하는 함수를 작성하고 DT를 만들어 편리하고 간단하게 웨이브마다 스폰되는 몬스터의 종류와 수를 설정할 수 있게 구현
아이템을 구현하여 레벨에 배치할 수 있게끔 설계하고 몬스터 처치 시 확률적으로 드랍하게 구현

< 내가 맡은 팀 내 역할 >

게임 플레이의 흐름을 구현
팀장으로서 팀원의 소통을 주도하고, 팀원간의 갈등을 조율하여 보다 성공적인 프로젝트의 마무리를 이끌어냄

< 이번 프로젝트를 진행하면서 느낀 나의 강점 >

게임의 기본적인 틀을 구상하고 각 파트마다 요청 사항을 작성하여 기획 단계에 설계한대로 구현하려고 소통하려는 능력
기본적인 구현에 끝나지 않고 추가 요소를 생각해내고 게임의 분위기를 고려하여 재미를 더할 수 있는 로직을 추천 및 요청하고 구현하는 능력

< 이번 프로젝트에서 가장 몰입했던 순간 >

다른 파트의 팀원분께 요청 사항을 작성하고, 해당 내용이 내가 구현하고 싶었던 내용과 일치하게 작동했을 때 성취감을 느낌
기본적인 테스트를 모두 마치고 오류 검출이 끝난 후 새로 작성한 내용들을 바탕으로 모든 파트의 코드를 조합해서 실제 게임과 같은 구현이 됐을 때

< 내가 팀에 기여했다고 생각하는 부분 >

하드 스킬 : 파트 별 작업 내용이 Merge됐을 때 본인 브랜치에 최신화를 한 후 테스트를 해보고 수치 조정이나 이펙트, 모션 등 피드백 및 코드 구현에 대해 함께 고민하고 방향성 제공
소프트 스킬 : 팀장의 역할로 현재 구현해야 할 내용들에 대한 순서도 및 중요도를 인지하고 팀원들에게 공유함으로써 합리적이고 신속한 개발에 이바지함

< 프로젝트를 진행하면서 아쉬웠던 것들 중 가장 성장한 부분 >

아쉬웠던 부분: 초반 팀원들과의 소통으로 인한 교류의 문제로 계획했던 진행에 차질이 생김
성장 과정: 틀어진 계획 내에서 우선 순위를 정하여 기초 구현으로 뼈대를 잡은 뒤 후에 작업할 내용을 팀원들과 의논하고 설계함
결과: 여러 문제가 생겼지만 높은 완성도를 갖춘 개발을 하여 기존 기획에서 크게 벗어나지 않은 개발을 이루어 냄

< 내가 맡았던 기술적 구현 중 가장 잘 되었다고 생각한 부분 >

데이터 테이블로 웨이브마다 호출되는 정보를 설정하여 어떤 포탈에서 어떤몬스터를 몇마리 소환할지 간편하게 설정할 수 있게 설계함
플레이어의 IA는 Character파트 안에 구현하게 설계하고, PFPlayerController에서 UI의 정보를 업데이트 해주는 함수들을 선언 및 정의하여 각 파트에서 UI의 출력 함수를 호출할 때 혼동이 없게 구현함

< 프로젝트 중 발생한 기술 문제를 내가 주도적으로 해결한 경험 >

문제:

레벨 및 몬스터를 구현했지만 어떤 레벨의 어떤 웨이브에서 어떤 몬스터가 나오게 만들지 구체화 하지 못하는 상황이 발생

과정:

총 4개의 레벨에 각각 3웨이브 씩 갖추게 하였고, 총 12개의 웨이브에서 어떤 몬스터를 얼마나 스폰할 지 직접 DT_Wave를 수정해가며 어떻게 게임을 구상할 지 계속 테스트 및 적용

결과:

각 레벨이 이동 할 때 Character의 HP를 GameInstance에 저장하고, 총기의 총알 및 데미지는 초기화하여 게임의 긴장감을 부여하고, 밸런스를 갖추어 너무 쉽지도 어렵지도 않은 적당한 난이도로 개선

< 팀원들과의 협업에서 내가 잘했다고 느낀 부분 >

문제 발생 시 회의를 이끌어 나가며 최선의 문제 해결 방안을 제안
작성한 코드를 구현하기 위해 다른 파트의 코드 구현 요청 사항을 상세하게 기입하여 요청 사항의 이유를 확실하게 납득시킴

< 프로젝트 중 발생한 협업 및 커뮤니케이션 문제를 내가 주도적으로 해결한 경험 >

문제:

각 파트마다 구현하는 것에 대한 생각이 각기 다름. 어느 분은 이 것 저 것 모두 구현을 하고 싶어하시고, 어떤 분은 필수 기본 구현만 갖추고 공부/휴식을 원하는 분도 계시는 상황

과정:

팀원간의 회의/소통을 주도하여 각 파트마다 기본 기능 구현을 모두 완료 하고, 특수 기능 구현 2가지 씩 추가하자고 제안하여 합의점을 이끌어 냄.

결과:

캐릭터 파트에서는 대쉬/대검 모션을 구현하였고, 몬스터 파트에서는 보스몬스터 / 자폭몬스터를 구현하였고, UI에서는 시네마틱 연출/ Kill Log를 구현하였고, GameManager 파트에서는 LevelPortal의Activate()/ DropItem()로 몬스터 처치 시 아이템 확률 드랍 코드를 구현하였다.

< 같은 프로젝트를 다시 한다면, 나는 어떤 역할을 맡고 싶고, 그 이유 >

캐릭터 파트 역할을 맡고 싶다.
- IA/IMC를 바인딩하여 캐릭터의 움직임을 대입시키고, 공격/이동/점프 등에 Animation을 적용하여 원하는 모션을 입혀 생동감있는 캐릭터 구현을 해보고 싶고, Game의 매커니즘/흐름에 맞게 알맞은 기능들을 구현해보고 싶다.(패링, 대쉬, 카운터, 로크라이크 기반 능력치 업그레이드 등)< 피드백 >

< 피드백 >

피드백 단계에서 본인이 질의응답에 참여하게 되었다.
왜 BP를 쓰지 않고 C++로 로직 구현을 했냐는 질문에 쉽사리 대답을 하지 못하였다. 질문 자체를 많이 받아보지 않았기에 느꼈던 심리적 상태 때문이었던 것 같다. 위와 같은 상황을 여러번 마주함으로써 질문 자체에 대한 거부감을 줄이고, 처음 기획단계때 설계했던 내용을 바탕으로 대답하면 좋을것같다고 느낀다.

7/27 TIL

blog13869 — Mon, 27 Jul 2026 20:32:21 +0900

[ 커리어데이 ]

오늘은 지난 프로젝트를 마친 후 회고, 브로셔 템플릿을 작성하는 활동을 하였다.

[ 브로셔 템플릿 ]

< 게임 개요 >

< 핵심 기능 >

< 캐릭터 대쉬 구현 >

< 보스몬스터 구현 >

< 핵심 기술 >

< Niagara System >

< 컴포넌트 기반 기능 구현 >

[ 기술적 의사결정 사례 ]

< UpdateUI 할당>

< SwitchWeapon - Sword >

< MonsterSpawnPortal >

[ 트러블 슈팅 사례 ]

< 롤백 >

< Build Failed >

< 인원 감소로 인한 작업 분배 >

[ 팀 구성 ]

7/24 TIL

blog13869 — Fri, 24 Jul 2026 21:02:07 +0900

[ PROJECT F ]

오늘 PPT 발표를 마치고 정상적으로 프로젝트를 완료 하였다.

7/23 TIL

blog13869 — Thu, 23 Jul 2026 21:03:26 +0900

[ PROJECT F ]

이게 코드 구현 마감을 마치고 제출용 영상 편집, PPT 작성에 이르렀다.

PPT

영상은 길이도 길고 아직 완성 전이라 내일 오전중으로 제출 예정이다.

나는 노션 브로셔 템플릿을 작성하였다.

7/22 TIL

blog13869 — Wed, 22 Jul 2026 21:02:10 +0900

[ PROJECT F ]

오늘로 모든 구현 작업을 끝내고 패키징을 완료했다.

각자 구현하기로 한 내용들을 모두 구현을 완료했고 성공적으로 마쳤다.

7/20 TIL

blog13869 — Mon, 20 Jul 2026 19:44:34 +0900

[ PROJECT F ]

오늘의 구현 목록

Grenade 쿨타임 호출용 함수 추가

[ PFPlayerController ]

< 헤더 파일 선언 >

void UpdateGrenadeCooldownUI(float GrenadeCooldown);

< 소스 파일 구현 >

void APFPlayerController::UpdateGrenadeCooldownUI(float GrenadeCooldown)
{
    if (HUDWidgetInstance == nullptr) return;
    FOutputDeviceNull Ar;
    FString Command = FString::Printf(TEXT("UpdateGrenadeCooldownUI %f"), GrenadeCooldown);
    HUDWidgetInstance->CallFunctionByNameWithArguments(*Command, Ar, nullptr, true);
}

[ PFCombatComponent ] // 작성 요쳥

< 헤더 파일 선언 >

protected:
    
    UPROPERTY(EditAnywhere, Category = "Combat")
    float GrenadeCooldown = 5.0f;

  
    bool bIsGrenadeOnCooldown = false;

 
    FTimerHandle GrenadeCooldownTimerHandle;

    
    void ResetGrenadeCooldown() { bIsGrenadeOnCooldown = false; };

< 소스 파일 구현 >

void UPFCombatComponent::ExecuteThrow()
{
    AActor* Owner = GetOwner();
    ACharacter* Character = Cast<ACharacter>(Owner);
    
    if (!Character || !GrenadeClass || GrenadeCount <= 0 || bIsGrenadeOnCooldown) return;

    if (HandGrenadeMesh)
    {
        HandGrenadeMesh->SetVisibility(false);
    }

    GrenadeCount--;

    FVector SpawnLocation = Character->GetMesh()->GetSocketLocation(HandSocketName); 
    FRotator SpawnRotation = Character->GetControlRotation();

    FActorSpawnParameters SpawnParams;
    SpawnParams.Owner = Owner;
    SpawnParams.Instigator = Character;

    GetWorld()->SpawnActor<APFGrenade>(GrenadeClass, SpawnLocation, SpawnRotation, SpawnParams);

    bIsGrenadeOnCooldown = true;

    APFPlayerController* PlayerController = Cast<APFPlayerController>(Character->GetController());
    if (PlayerController)
    {
        PlayerController->UpdateGrenadeCooldownUI(GrenadeCooldown); 
    }

    GetWorld()->GetTimerManager().SetTimer(
        GrenadeCooldownTimerHandle, 
        this, 
        &UPFCombatComponent::ResetGrenadeCooldown, 
        GrenadeCooldown, 
        false
    );
}

GameClear 함수 작성 및 최종 구현 완료

< PFGameMode.cpp >

void APFGameMode::OnMonsterKilled()
{
    if (!PFGameState) return;
    PFGameState->OnMonsterKilled();
    UE_LOG(LogTemp, Log, TEXT("몬스터 처치! 남은 몬스터: %d"), PFGameState->GetRemainingMonsters());

    if (PFGameState->GetRemainingMonsters() <= 0)
    {
       //   4레벨 3웨이브(최종 보스)를 잡았는지 확인
       if (PFGameState->GetCurrentLevel() == 4 && PFGameState->GetCurrentWave() == 3)
       {
          APFPlayerController* PlayerController = Cast<APFPlayerController>(GetWorld()->GetFirstPlayerController());
          if (PlayerController)
          {
             PlayerController->ShowGameOver(true); // true = 게임 클리어!
          } // true = 승리/게임클리어!
       }
       else
       {
          WaveClear(); // 다음 웨이브 진행
       }
    }
    
}

void APFGameMode::GameOver()
{
    GetWorldTimerManager().ClearTimer(PFTimerHandle);
    UE_LOG(LogTemp, Warning, TEXT("Game Over!"));

    if (APFPlayerController* PlayerController = Cast<APFPlayerController>(GetWorld()->GetFirstPlayerController()))
    {
       PlayerController->ShowGameOver(false);
    }
}

< PFPlayerController.h >

UPROPERTY(EditDefaultsOnly, Category = "UI")
TSubclassOf<UUserWidget> GameClearWidgetClass;

< PFPlayerController.cpp >

void APFPlayerController::ShowGameOver(bool bIsClear)
{
    if (HUDWidgetInstance) 
    {
     HUDWidgetInstance->RemoveFromParent(); 
     HUDWidgetInstance = nullptr; 
    }
     
    // bIsClear 조건에 따라 띄울 위젯 클래스 결정 
    TSubclassOf<UUserWidget> TargetWidgetClass = bIsClear ? GameClearWidgetClass : GameOverWidgetClass;
    
    // 위젯 생성 및 화면 표시
    if (TargetWidgetClass)
        {
            GameOverWidgetInstance = CreateWidget<UUserWidget>(this, TargetWidgetClass);
            if (GameOverWidgetInstance)
            {
                GameOverWidgetInstance->AddToViewport(); 

                // 마우스 커서 활성화 및 UI 입력 모드로 전환
                bShowMouseCursor = true; 
                FInputModeUIOnly InputModeData;
                InputModeData.SetWidgetToFocus(GameOverWidgetInstance->TakeWidget());
                SetInputMode(InputModeData);
            }
        }
}

< BP_PFPlayerController >

7/15 TIL

blog13869 — Wed, 15 Jul 2026 19:39:16 +0900

[ PROJECT F ]

오늘의 구현 목록

[ 수류탄 코드 구현 ]

< PFGrenade >

< 헤더 파일 >

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "PFGameMode.generated.h"

/**
 * 
 */
class APFGameState;
class APFLevelPortal;
class APFBaseItem;

UCLASS()
class PROJECTF_API APFGameMode : public AGameModeBase
{
    GENERATED_BODY()
    
public:
    
    APFGameMode();
    
    void OnMonsterKilled();
    
    void ProceedToNextLevel();
    
    // 게임오버 이동
    void GameOver();
    
    UFUNCTION(BlueprintCallable, Category = "Item|Drop")
    void HandleMonsterDeath(const FVector& SpawnLocation);
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "UI")
    TSubclassOf<class UUserWidget> LoadingWidgetClass;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item|Classes")
    TSubclassOf<APFBaseItem> HealingItemClass;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item|Classes")
    TSubclassOf<APFBaseItem> PistolAmmoClass;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item|Classes")
    TSubclassOf<APFBaseItem> RifleAmmoClass;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item|Classes")
    TSubclassOf<APFBaseItem> GrenadeItemClass;

    // 기본 드랍 확률 (20%)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item|DropSettings")
    float OverallDropChance = 0.2f;
    
    void RegisterLevelPortal(class APFLevelPortal* Portal) { LevelPortalInstance = Portal; }
    
protected:
    
    virtual void BeginPlay() override;
    
    void TimerCountDown();
    void StartWave();
    void WaveClear();
    void LevelClear();
    
    
    
private:
    
    void SpawnRandomItem(const FVector& SpawnLocation, int32 CurrentLevel);
    
    UPROPERTY(VisibleAnywhere, Category = "Game Data")
    APFGameState* PFGameState;
    
    FTimerHandle PFTimerHandle;
    
    UPROPERTY()
    class APFWaveManager* PFWaveManager;
    UPROPERTY()
    class APFSpawnManager* PFSpawnManager;
    
    UPROPERTY(EditAnywhere, Category = "Wave Data")
    UDataTable* WaveDataTableAsset;
    
    class APFLevelPortal* LevelPortalInstance;
};

< 소스 파일 >

#include "Weapon/PFGrenade.h"
#include "Components/SphereComponent.h"
#include "Components/StaticMeshComponent.h"
#include "GameFramework/ProjectileMovementComponent.h"
#include "Kismet/GameplayStatics.h" 
#include "NiagaraComponent.h" 
#include "DrawDebugHelpers.h"
#include "Monster/PFMonsterCharacter.h"


APFGrenade::APFGrenade()
{
    PrimaryActorTick.bCanEverTick = false;

    CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
    CollisionComponent->InitSphereRadius(10.0f);
    CollisionComponent->SetCollisionProfileName(TEXT("BlockAll"));
    RootComponent = CollisionComponent;

    GrenadeMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("GrenadeMesh"));
    GrenadeMesh->SetupAttachment(RootComponent);
    
    ExplosionSphereComponent = CreateDefaultSubobject<USphereComponent>(TEXT("ExplosionSphereComponent"));
    ExplosionSphereComponent->SetupAttachment(RootComponent);
    ExplosionSphereComponent->InitSphereRadius(400.0f);
    ExplosionSphereComponent->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    ExplosionSphereComponent->SetCollisionProfileName(TEXT("OverlapAllDynamic"));

    ExplosionEffect = CreateDefaultSubobject<UNiagaraComponent>(TEXT("ExplosionEffect"));
    ExplosionEffect->SetupAttachment(RootComponent);
    ExplosionEffect->bAutoActivate = false;
    
    ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileMovement"));
    ProjectileMovement->UpdatedComponent = CollisionComponent;
    ProjectileMovement->InitialSpeed = 1500.f;
    ProjectileMovement->MaxSpeed = 1500.f;
    ProjectileMovement->bRotationFollowsVelocity = true;
    ProjectileMovement->bShouldBounce = true;
    ProjectileMovement->Bounciness = 0.3f;
}


void APFGrenade::BeginPlay()
{
    Super::BeginPlay();
    // 타이머 설정
    GetWorldTimerManager().SetTimer(ExplodeTimerHandle, this, &APFGrenade::Explode, FuseTime, false);
}



void APFGrenade::Explode()
{
    FVector ExplodeLocation = GetActorLocation();

    // 나이아가라 이펙트 on(활성화)
    if (ExplosionEffect)
    {
       ExplosionEffect->DetachFromComponent(FDetachmentTransformRules::KeepWorldTransform);
       ExplosionEffect->Activate(true);
    }

    // 청각 효과 (사운드 재생)
    if (ExplosionSound)
    {
       UGameplayStatics::PlaySoundAtLocation(GetWorld(), ExplosionSound, ExplodeLocation);
    }

    if (ExplosionSphereComponent)
    {
       TArray<AActor*> OverlappingActors;
        
       //  ExplosionSphereComponent 이랑 overlap된 액터 탐색
       ExplosionSphereComponent->GetOverlappingActors(OverlappingActors);

       for (AActor* HitActor : OverlappingActors)
       {
          if (HitActor)
          {
             // 몬스터만 피격
             APFMonsterCharacter* Monster = Cast<APFMonsterCharacter>(HitActor);
             if (Monster)
             {
                Monster->TakeDamageFromMonster(ExplosionDamage, GetOwner());
                    
                UE_LOG(LogTemp, Log, TEXT("[Grenade] %s 몬스터에게 수류탄 데미지 %f 적용 완료!"), 
                   *Monster->GetName(), ExplosionDamage);
             }
          }
       }
    }

    // 이후 처리
    if (GrenadeMesh)
    {
       GrenadeMesh->SetHiddenInGame(true);
    }
    
    if (CollisionComponent)
    {
       CollisionComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    }
    
    if (ProjectileMovement)
    {
       ProjectileMovement->StopMovementImmediately();
    }

    FTimerHandle DestroyTimerHandle;
    GetWorldTimerManager().SetTimer(DestroyTimerHandle, [this]()
       {this->Destroy();}, 5.0f, false);
}

< 이 후 BP 래핑 >

< 수류탄 효과 (TakeDamageFromMonster)는 적용되는데 나이아가라 이펙트가 나오지않는 이슈 발생 >

해결 방법

CombatComponent 에서의 Grenade Class 를 작성한 BP_PFGrenade_N으로 교체

< 테스트 화면 >

[ 몬스터 스폰 포탈, Level포탈/보스 포탈 나이아가라 이펙트 수정 ]

몬스터 포탈

보스/레벨 포탈