언리얼 학습 기록

최종 팀 프로젝트 커스터마이징 시스템 데이터화 및 UI 구현

Turtle_Jun — Thu, 4 Dec 2025 23:36:05 +0900

Customize 기능 구현

UE5 모듈러 캐릭터 커스터마이징 시스템 구현 정리

1. 개요

프로젝트에서는 캐릭터의 파츠(상의, 하의, 헤어, 장갑 등)를 런타임에서 자유롭게 변경하는 모듈형 시스템(Modular Character System)을 구현했다.

주요 요구사항은 다음과 같다.

모듈 파츠 구조를 스켈레탈 메시 단위로 유연하게 교체
여러 파츠를 조합할 수 있는 FastArray 기반 구조
클라이언트 UI에서 선택한 파츠를 서버에서 장착 후 모든 클라이언트에 반영
특정 액터 근처에서 커스터마이징 UI 자동 열림
파츠 목록은 DataTable 기반으로 관리
슬롯(부위)별 탭, 슬롯별 파츠 표시, 클릭하여 즉시 변경

아래는 전체 구현 과정을 설명과 코드 중심으로 정리한 내용이다.

캐릭터 모듈 정의

캐릭터 파츠들을 파악한 후 Enum 형으로 파츠를 정의해준다.

파츠의 데이터 구조
FastArrayReplication 기반 파츠 리스트

2.1 파츠 데이터 구조 (FCharacterPart)

// CharacterPartType.h

// 파츠 슬롯 정의 (모자, 상의, 하의, 몸통 등)
UENUM(BlueprintType)
enum class ECharacterPartSlot : uint8
{
    None,
    Backpacks, //    가방
    Beards, //    수염
    Body, //    몸 (피부 색)
    Boots, // 신발
    Brows, //    눈썹
    Eyes, // 눈
    Glasses, // 안경
    Gloves, // 장갑
    Hairs, // 머리카락
    Hats,    // 모자
    Pants, // 바지
    Suits,    // 한벌 옷
    Upper_Wear    // 상의
};

/*
 * 단일 파츠 정보 구조체 (어떤 슬롯에 어떤 메시를 쓸지 결정)
 */
USTRUCT(BlueprintType)
struct FCharacterPart
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cosmetic")
    ECharacterPartSlot Slot = ECharacterPartSlot::None;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cosmetic")
    TObjectPtr<USkeletalMesh> Mesh = nullptr;
};

2.2 파츠 리스트 (FFastArraySerializer)

/*
 *    개별 적용된 파츠 배열의 개별 항목
 */
USTRUCT()
struct FAppliedCharacterPartEntry : public FFastArraySerializerItem
{
    GENERATED_BODY()

    // 적용된 파츠의 데이터(부위, 메시) / 네트워크 복제 ㅇ
    UPROPERTY()
    FCharacterPart Part;

    // 런타임에 생성된 스켈레탈 메쉬 컴포넌트 포인터    / 복제 X
    UPROPERTY(NotReplicated)
    TObjectPtr<USkeletalMeshComponent> SpawnedComponent = nullptr;
};

// 캐릭터에 적용된 모든 파츠 목록을 관리하는 구조체 / 네트워크 최적화
USTRUCT()
struct FCharacterPartList : public FFastArraySerializer
{
    GENERATED_BODY()

public:
    FCharacterPartList() : OwnerComponent(nullptr)
    {
    }

    FCharacterPartList(ULNCharacterPartComponent* InOwnerComponent) : OwnerComponent(InOwnerComponent)
    {
    }

    void PreReplicatedRemove(const TArrayView<int32> RemoveIndices, int32 FinalSize);
    void PostReplicatedAdd(const TArrayView<int32> AddIndices, int32 FinalSize);
    void PostReplicatedChange(const TArrayView<int32> ChangeIndices, int32 FinalSize);

    bool NetDeltaSerialize(FNetDeltaSerializeInfo& DeltaParms)
    {
        return FastArrayDeltaSerialize<FAppliedCharacterPartEntry, FCharacterPartList>(Entries, DeltaParms, *this);
    }

    // 스켈레탈 메쉬 컴포넌트 생성 후 부착하는 함수
    void SpawnMeshForEntry(FAppliedCharacterPartEntry& Entry);
    // 스켈레탈 메쉬 컴포넌트 제거하는 함수
    void DestroyMeshForEntry(FAppliedCharacterPartEntry& Entry);

    UPROPERTY()
    TArray<FAppliedCharacterPartEntry> Entries;

    UPROPERTY(NotReplicated)
    TObjectPtr<ULNCharacterPartComponent> OwnerComponent;
};

2.3 TStructOpsTypeTraits (FastArray Serializer 사용 선언)

// 템플릿 특수화
template <>
struct TStructOpsTypeTraits<FCharacterPartList> : public TStructOpsTypeTraitsBase2<FCharacterPartList>
{
    enum { WithNetDeltaSerializer = true };
};

3. 캐릭터 파츠 변경을 담당하는 컴포넌트

컴포넌트 이름: ULNCharacterPartComponent

3.1 파츠 적용 요청 함수 (서버 전용)

// LNCharacterPartComponent.h

#include "LNCharacterPartComponent.h"

#include "GameFramework/Character.h"
#include "Net/UnrealNetwork.h"

ULNCharacterPartComponent::ULNCharacterPartComponent()
    : AppliedCharacterPartList(this)    
{
    SetIsReplicatedByDefault(true);
}

void ULNCharacterPartComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    DOREPLIFETIME(ThisClass, AppliedCharacterPartList);    //적용된 파츠들 네트워크 복제
}

void ULNCharacterPartComponent::SetCharacterPart(const FCharacterPart& NewPart)
{
    if (!GetOwner() || !GetOwner()->HasAuthority())
        return;

    //  Suits 들어오면 유지할 파츠만 남기기
    if (NewPart.Slot == ECharacterPartSlot::Suits)
    {
        // 유지할 슬롯 목록
        TSet<ECharacterPartSlot> SlotsToKeep =
        {
            ECharacterPartSlot::Body,
            ECharacterPartSlot::Eyes,
            ECharacterPartSlot::Brows,
            ECharacterPartSlot::Suits   // 자기가 들어갈 슬롯 포함
        };

        for (auto It = AppliedCharacterPartList.Entries.CreateIterator(); It; ++It)
        {
            if (!SlotsToKeep.Contains(It->Part.Slot))
            {
                // 제거
                AppliedCharacterPartList.DestroyMeshForEntry(*It);
                It.RemoveCurrent();
                AppliedCharacterPartList.MarkArrayDirty();
            }
        }
    }
    //  여기까지 Suits 특수 로직 

    // 기존 슬롯 제거 및 Suits가 남아있다면 Suits 제거 (중복 슬롯 제거 및 Suits 제거)
    for (auto It = AppliedCharacterPartList.Entries.CreateIterator(); It; ++It)
    {
        if (It->Part.Slot == NewPart.Slot || It->Part.Slot == ECharacterPartSlot::Suits)
        {
            AppliedCharacterPartList.DestroyMeshForEntry(*It);
            It.RemoveCurrent();
            AppliedCharacterPartList.MarkArrayDirty();
            //break;
        }
    }

    if (!IsValid(NewPart.Mesh)) return;

    // 새로운 엔트리 추가
    FAppliedCharacterPartEntry& NewEntry = AppliedCharacterPartList.Entries.AddDefaulted_GetRef();
    NewEntry.Part = NewPart;

    AppliedCharacterPartList.SpawnMeshForEntry(NewEntry);
    AppliedCharacterPartList.MarkItemDirty(NewEntry);   // replication notify
}

USkeletalMeshComponent* ULNCharacterPartComponent::GetParentMeshComponent() const
{
    if (ACharacter* Char = Cast<ACharacter>(GetOwner()))
    {
        return Char->GetMesh();
    }
    return nullptr;
}

3.2 파츠 추가/제거 복제 처리

FastArraySerializer에서는 클라이언트가 직접 파츠를 생성하지 않고,

서버 변경 후 아래 함수들이 클라이언트에서 자동 호출된다.

// CharacterPartType.cpp

#include "LNCharacterPartType.h"
#include "LNCharacterPartComponent.h"
#include "Components/SkeletalMeshComponent.h"

//    서버에서 파츠 제거되었다는 정보 도착시 클라이언트에서 호출
void FCharacterPartList::PreReplicatedRemove(const TArrayView<int32> RemoveIndices, int32 FinalSize)
{
    for (const int32 Index : RemoveIndices)
    {
        FAppliedCharacterPartEntry& Entry = Entries[Index];
        DestroyMeshForEntry(Entry);
    }
}

//    서버에서 새로운 파츠가 추가 되었다는 정보 도착시 클라이언트에서 호출
void FCharacterPartList::PostReplicatedAdd(const TArrayView<int32> AddIndices, int32 FinalSize)
{
    for (const int32 Index : AddIndices)
    {
        FAppliedCharacterPartEntry& Entry = Entries[Index];
        SpawnMeshForEntry(Entry);
    }
}

//    서버에서 기존 파츠의 정보가 변경될 때 클라에서 호출
void FCharacterPartList::PostReplicatedChange(const TArrayView<int32> ChangeIndices, int32 FinalSize)
{
    for (const int32 Index : ChangeIndices)
    {
        FAppliedCharacterPartEntry& Entry = Entries[Index];
        DestroyMeshForEntry(Entry);
        SpawnMeshForEntry(Entry);
    }
}

//    파츠 데이터를 기반으로 실제 스켈레탈 메시 컴포넌트를 생성하고 캐릭터에 부착
void FCharacterPartList::SpawnMeshForEntry(FAppliedCharacterPartEntry& Entry)
{
    if (!IsValid(OwnerComponent) || !IsValid(Entry.Part.Mesh)) return;

    USkeletalMeshComponent* ParentMesh = OwnerComponent->GetParentMeshComponent();
    if (!IsValid(ParentMesh)) return;    

    AActor* OwnerActor = OwnerComponent->GetOwner();

    FName ComponentName = *FString::Printf(TEXT("CosmeticPart_%s"), *UEnum::GetValueAsString(Entry.Part.Slot));
    USkeletalMeshComponent* NewPartComponent = NewObject<USkeletalMeshComponent>(OwnerActor, ComponentName);

    NewPartComponent->SetupAttachment(ParentMesh);

    NewPartComponent->SetSkeletalMesh(Entry.Part.Mesh);

    // 모든 파츠 컴포넌트가 부모(몸통)의 애니를 그대로 따라가도록 설정
    NewPartComponent->SetLeaderPoseComponent(ParentMesh);

    NewPartComponent->RegisterComponent();

    Entry.SpawnedComponent = NewPartComponent;
}

// 파츠 제거될때 생성한 스켈레탈 메쉬를 안전하게 제거
void FCharacterPartList::DestroyMeshForEntry(FAppliedCharacterPartEntry& Entry)
{
    if (IsValid(Entry.SpawnedComponent))
    {
        Entry.SpawnedComponent->DestroyComponent();
        Entry.SpawnedComponent = nullptr;
    }
}

4. 파츠 데이터 관리(DataTable 기반)

파츠는 DataTable을 사용해 부위별로 관리한다.

4.1 DataTable Row 구조 FPartRow

// CharacterPartRow.h

#pragma once

#include "CoreMinimal.h"
#include "Engine/DataTable.h"
#include "LNCharacterPartRow.generated.h"

USTRUCT(BlueprintType)
struct FCharacterPartRow : public FTableRowBase
{
    GENERATED_BODY()

public:

    // UI에 표시할 아이콘
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    TObjectPtr<UTexture2D> Icon;

    // 장착될 스케레탈 메쉬
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    TObjectPtr<USkeletalMesh> Mesh;

};

4.2 카테고리 구조(FPartCategory)

// CharacterPartCategory.h

#pragma once

#include "CoreMinimal.h"
#include "Character/Components/LNCharacterPartType.h"
#include "LNCharacterPartCategory.generated.h"

USTRUCT(BlueprintType)
struct FCharacterPartCategory
{
    GENERATED_BODY()

public:
    // 어떤 파츠 슬롯인지 선택 ( 상/하의 등 )
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    ECharacterPartSlot Slot = ECharacterPartSlot::None;

    // 해당 파츠의 데이터 테이블
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    TObjectPtr<UDataTable> CharacterPartTable = nullptr;

    // UI 에서 보여줄 이름
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    FText DisplayName;
};

5. 커스터마이징 UI 구조

UI는 다음 구성으로 제작하였다.

상단 탭 버튼 (각 부위)
ScrollBox 내부 GridPanel (파츠 목록)
파츠 아이템은 동적 생성 (WBP_PartItem)

5.1 탭 클릭 시 파츠 로드 (LoadPartCategory 함수구현)

// CharacterCustomizeWidget.cpp

#include "UI/Widget/LNCharacterCustomizeWidget.h"

#include "Character/LNCharacter.h"
#include "Character/Components/LNCharacterPartComponent.h"
#include "Components/Button.h"
#include "UI/Widget/LNCharacterPartItemWidget.h"
#include "Components/GridPanel.h"
#include "Components/GridSlot.h"
#include "Hash/BuzHash.h"
#include "Player/Controller/LNControllerInGame.h"

void ULNCharacterCustomizeWidget::NativeConstruct()
{
    Super::NativeConstruct();
    Button_Close->OnClicked.AddDynamic(this, &ThisClass::HandleCloseWidget);
}

// WBP에서 CategoryTab 버튼 생성후LoadPartCategory 실행
void ULNCharacterCustomizeWidget::LoadPartCategory(ECharacterPartSlot PartSlot)
{
    // 현재 UI 화면 정리
    GridPanel_Parts->ClearChildren();

    // 파츠 슬롯 저장
    CurrentSlot = PartSlot;

    for (const FCharacterPartCategory& Category : PartCategories)
    {
        if (Category.Slot != PartSlot) continue;

        ECharacterPartSlot CharPartSlot = Category.Slot;

        // 해당 슬롯의 DataTable 가져오기
        UDataTable* DataTable = Category.CharacterPartTable;

        if (!DataTable || !PartItemClass) return;

        TArray<FCharacterPartRow*> Rows;
        DataTable->GetAllRows(TEXT("Load"), Rows);

        int32 Index = 0;

        for (auto* Row : Rows)
        {
            ULNCharacterPartItemWidget* ItemWidget = CreateWidget<
                ULNCharacterPartItemWidget>(GetWorld(), PartItemClass);
            ItemWidget->Init(Row->Icon, CharPartSlot, Row->Mesh);
            // PartItemWidget에 있는 OnclickedPartItem 델리게이트 바인딩
            ItemWidget->OnClickedPartItem.AddDynamic(this, &ThisClass::HandlePartItemClicked);

            int32 RowIndex = Index / GridRowSize;
            int32 ColIndex = Index % GridRowSize;

            GridPanel_Parts->AddChildToGrid(ItemWidget, RowIndex, ColIndex);
            Index++;
        }

        return;
    }
}

void ULNCharacterCustomizeWidget::HandlePartItemClicked(ECharacterPartSlot NewPartSlot, USkeletalMesh* Mesh)
{
    ALNControllerInGame* PC = Cast<ALNControllerInGame>(GetOwningPlayer());
    if (!IsValid(PC)) return;

    // Character컴포넌트의 SetCharacterPart 호출
    PC->Server_RequestEquipPart(NewPartSlot, Mesh);
}

void ULNCharacterCustomizeWidget::HandleCloseWidget()
{
    ALNControllerInGame* PC = Cast<ALNControllerInGame>(GetOwningPlayer());
    if (!IsValid(PC)) return;

    PC->Client_CloseCustomizeUI();
}

6. 클라이언트 → 서버 파츠 변경 요청

UI에서 직접 파츠를 변경하는 것은 안 된다.

서버가 권한(Authority)을 갖고 있으므로 PlayerController를 통한 Server RPC가 필수이다.

6.1 PlayerController RPC

// ControllerInGame.h

// ======= 캐릭터 파츠 요청
UFUNCTION(Server, Reliable)
void Server_RequestEquipPart(FGameplayTag SlotTag, USkeletalMesh* Mesh);

//======= 클라이언트 UI 열고 닫기

    // 커스터마이즈 UI 열기
    UFUNCTION(Client, Reliable, Category="LN|Customize")
    void Client_OpenCustomizeUI();

    // 커스터마이스 UI 닫기
    UFUNCTION(Client, Reliable, Category="LN|Customize")
    void Client_CloseCustomizeUI();

// ControllerInGame.cpp

void AMyPlayerController::Server_RequestEquipPart_Implementation(FGameplayTag SlotTag, USkeletalMesh* Mesh)
{
    APawn* Pawn = GetPawn();
    if (!Pawn) return;

    ULNCharacterPartComponent* Comp = Pawn->FindComponentByClass<ULNCharacterPartComponent>();
    if (!Comp) return;

    FCharacterPart NewPart;
    NewPart.SlotTag = SlotTag;
    NewPart.Mesh = Mesh;

    Comp->SetCharacterPart(NewPart);
}

void ALNControllerInGame::Client_OpenCustomizeUI_Implementation()
{
    if (!IsValid(CustomizeMenuClass)) return;

    if (CustomizeWidget == nullptr)
    {
        CustomizeWidget = CreateWidget(this, CustomizeMenuClass);
    }

    if (CustomizeWidget && !CustomizeWidget->IsInViewport())
    {
        CustomizeWidget->AddToViewport();

        // Cusomize 중 캐릭이동 불가능
        FInputModeUIOnly InputMode;
        InputMode.SetWidgetToFocus(CustomizeWidget->TakeWidget());
        InputMode.SetLockMouseToViewportBehavior(EMouseLockMode::DoNotLock);
        SetInputMode(InputMode);

        bShowMouseCursor = true;
    }
}

void ALNControllerInGame::Client_CloseCustomizeUI_Implementation()
{
    if (CustomizeWidget && CustomizeWidget->IsInViewport())
    {
        CustomizeWidget->RemoveFromParent();
    }

    FInputModeGameOnly InputMode;
    SetInputMode(InputMode);
    bShowMouseCursor = false;
}

7. 커스터마이징 스테이션 (상호작용 인터페이스)

플레이어가 특정 액터 근처로 접근 후 상호작용을 하면

커스터마이징 메뉴가 열리는 액터를 구현

7.1 커스터마이징 스테이션 액터

// LNCustomizeStation.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Interface/LNIInteractable.h"
#include "LNCustomizeStation.generated.h"

class UStaticMeshComponent;
class USphereComponent;

UCLASS()
class OURLONGNIGHT_API ALNCustomizeStation : public AActor, public ILNIInteractable
{
    GENERATED_BODY()

public:    
    ALNCustomizeStation();

    virtual void BeginPlay() override;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    TObjectPtr<UStaticMeshComponent> StationMesh;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    TObjectPtr<USphereComponent> TriggerSphere;

    virtual void LeftClickInteract(AActor* Interactor) override;
    virtual void RightClickInteract(AActor* Interactor) override;
};

// LNCustomizeStation.cpp

#include "Character/LNCustomizeStation.h"

#include "LNCharacter.h"
#include "Player/Controller/LNControllerInGame.h"
#include "Components/SphereComponent.h"

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

    StationMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StationMesh"));
    RootComponent = StationMesh;

}

void ALNCustomizeStation::BeginPlay()
{
    Super::BeginPlay();

}

void ALNCustomizeStation::LeftClickInteract(AActor* Interactor)
{
    ALNCharacter* Character = Cast<ALNCharacter>(Interactor);
    if (!IsValid(Character)) return;

    ALNControllerInGame* PC = Cast<ALNControllerInGame>(Character->GetController());
    if (!IsValid(PC)) return;

    // 커스터마이징 메뉴 생성
    PC->Client_OpenCustomizeUI();
}

void ALNCustomizeStation::RightClickInteract(AActor* Interactor)
{
    // 필요시 구현
}

Interact 인터페이스 구현

해당 기록 보드에서 생성한 Interactible 콜리전 프리셋을 해당 액터에 적용해준다.

9. 동작 흐름 정리

플레이어가 커스터마이징 스테이션 근처에 접근
PlayerController(Client_OpenCustomizeUI) 호출
UI에서 파츠 선택
Server_RequestEquipPart() 실행
서버에서 SetCharacterPart() 실행
FastArrayReplication으로 모든 클라이언트에 변경 사항 동기화
SpawnMeshForEntry / DestroyMeshForEntry 가 클라이언트에서 자동으로 호출
실제 스켈레탈 메시 구성 갱신

언리얼 팀프로젝트최종 팀 프로젝트 Interact 캐릭터에 적용

Turtle_Jun — Thu, 27 Nov 2025 21:40:10 +0900

[이전 시간에 구현한 Interface] (https://unrealstudyhome.tistory.com/109)

┌─────────────────┐
│ ILNIInteractable │ ← 인터페이스
└────────┬────────┘
│ implements
┌────┴─────┬──────────┐
│ │ │
┌───▼───┐ ┌───▼───┐ ┌───▼───┐
│Character │ │ 기믹1 │ │ 기믹2 │
└───────┘ └───────┘ └────────┘

각 기믹들과 캐릭터에 한해서 상호작용 인터페이스를 상속 받아 구현을 한 후

캐릭터의 입력을 받아서 각자에 맞는 상호작용 로직을 호출하는 형식으로 구현함

캐릭터에서 액터 상호작용 입력흐름 구조는 아래와 같다.

에디터 테스트 방법


void ALNCharacter::LeftClickInteract(AActor* Interactor)
{
    // 서버에서만 실행
    if (!HasAuthority())
    {
        UE_LOG(LogTemplateCharacter, Warning, TEXT("LeftClickInteract called on client"));
        return;
    }

    if (!Interactor)
    {
        UE_LOG(LogTemplateCharacter, Warning, TEXT("Interactor is null"));
        return;
    }

    // 캐릭터를 잡는 로직
    ALNCharacter* InteractorChar = Cast<ALNCharacter>(Interactor);
    if (!InteractorChar || !InteractorChar->GrabComponent)
    {
        UE_LOG(LogTemplateCharacter, Warning, TEXT("Invalid Interactor or GrabComponent"));
        return;
    }

    // GrabComponent를 통해 잡기 시도
    InteractorChar->GrabComponent->HandleGrabRequest(this);

    UE_LOG(LogTemplateCharacter, Log, TEXT("[Server] %s grabbed by %s"),
           *GetName(), *Interactor->GetName());
}

void ALNCharacter::RightClickInteract(AActor* Interactor)
{
    // 서버에서만 실행
    if (!HasAuthority())
    {
        UE_LOG(LogTemplateCharacter, Warning, TEXT("RightClickInteract called on client"));
        return;
    }

    if (!Interactor || !GetCharacterMovement())
    {
        return;
    }

    ALNCharacter* InteractorChar = Cast<ALNCharacter>(Interactor);
    if (!InteractorChar)
    {
        return;
    }

    // 상호작용시전한 캐릭터의 밀기 애니메이션 동작
    InteractorChar->Server_PlayMontage(InteractorChar->CharacterPushMontage, InteractorChar->MontagePlayRate);

    // 밀치는 방향 계산
    FVector LaunchDirection = InteractorChar->GetActorForwardVector().GetSafeNormal();
    FVector LaunchVelocity = LaunchDirection * 1000.0f + FVector(0, 0, 300.0f);

    // 캐릭터를 날림
    LaunchCharacter(LaunchVelocity, true, true);

    UE_LOG(LogTemplateCharacter, Log, TEXT("[Server] %s pushed by %s"),
           *GetName(), *Interactor->GetName());
}

기존 캐릭터 상호작용 로직을 인터페이스를 사용하여 구현하였다.

캐릭터 상호작용 자료 서칭

Turtle_Jun — Fri, 14 Nov 2025 22:02:05 +0900

How To Pick Up And Drag Ragdoll Bodies | Unreal Engine 5 Tutorial

캐릭터 상호작용으로 다른 플레이어를 잡았을때 끌고 올수 있는 방법에 대한 자료 서칭을 하였다.

Physics Constrain을 사용해서 캐릭터를 잡아 움직일 수 있도록 하면 될거같은데 위 영상도 참고하여 구현을 어떻게 할지 구상해보았다.

최종 팀 프로젝트 Interact 인터페이스 구현

Turtle_Jun — Thu, 13 Nov 2025 22:26:30 +0900

캐릭터 Mouse R/L Click에 따라 상호작용을 할 수 있도록 하며 다형성을 위해 인터페이스로 구현을 해뒀다

캐릭터에 맞는 Interact는 구현이 완료 되는 대로 글을 작성할 예정이다.

최종 팀 프로젝트 Interact 인터페이스 및 Pickup 로직 수정 기획

Turtle_Jun — Wed, 12 Nov 2025 22:55:04 +0900

애니메이션 및 동작 구현
- Interact, Pickup, 밀치기

기존 Pikcup 로직 -> Component로 구현하기

Interact : IInteractable 인터페이스 구현 후

Character에서 Interact 로직 구현 Figma참고

PickUp 리플리케이션 및 콜리전 경고 메세지 문제 해결

Turtle_Jun — Tue, 11 Nov 2025 23:44:09 +0900

2025.11.10 - [트러블 슈팅] - PickUp 기능

PickUp 기능

트러블 슈팅픽업 시 들고있는 오브젝트가 리플리케이션 안되는 문제콜리전 프리셋을 에디터에서 수정시 픽업이 되지 않는 문제해결 방안 모색 콜리전 프로파일 채널을 추가하고 리플리케이션

unrealstudyhome.tistory.com

// LNCharacter.h

#pragma region PickupSystem
	
protected:
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Pickup")
	UPhysicsHandleComponent* PhysicsHandle;

	UPROPERTY(ReplicatedUsing = OnRep_CarriedObject)
	TObjectPtr<AActor> CarriedObject;	// 잡고있는 오브젝트

	// 이전에 들고 있던 물체 추적용
	TObjectPtr<AActor> LastCarriedObject;

	UPROPERTY(EditDefaultsOnly, Category = "Pickup")
	FName PickupSocketName = TEXT("PickupSocket");
	
	UPROPERTY(EditDefaultsOnly, Category = "Pickup")
	float PickupDistance = 70.f;

	UPROPERTY(EditDefaultsOnly, Category = "Pickup")
	FVector PickupOffset = FVector(0.f, 0.f, 0.f);

	UPROPERTY(EditDefaultsOnly, Category = "Pickup")
	float PickupTraceRadius = 25.f;

	ECollisionEnabled::Type HeldItemCollisionType;	// 잡고있는 오브젝트의 콜리전 타입 저장
	
	void PickupObject(AActor* TargetActor);
	void ReleasePickupObject();

	// 실제 물리적 Attach/Detach 로직(서버와 클라 모두 실행) 
	void AttachCarriedObject();
	void DetachCarriedObject();
	
	FTimerHandle PickupUpdateTimerHandle;
	
#pragma endregion PickupSystem

// LNCharacter.cpp

void ALNCharacter::HandlePickup(const FInputActionValue& Value)
{
	UE_LOG(LogTemplateCharacter, Warning, TEXT("PickupHandle"));

	// 들고있다면 내려놓기
	if (IsValid(CarriedObject))
	{
		if (!HasAuthority())
		{
			ServerRPC_HandlePickup(CarriedObject, false);
		}
		else
		{
			ReleasePickupObject();
		}

		return;	// 내려놓고 종료
	}

	// 들고 있지 않다면 -> 전방 트레이스로 물체 찾기
	const FVector Start = GetActorLocation();
	const FVector End = Start + GetActorForwardVector() * PickupDistance;
	
	FHitResult Hit;
	FCollisionQueryParams Params;
	Params.AddIgnoredActor(this);
	float PicupTraceCapsuleHalfHeight = this->GetCapsuleComponent()->GetScaledCapsuleHalfHeight();

	
	bool bHit = GetWorld()->SweepSingleByObjectType(
		Hit,
		Start,
		End,
		FQuat::Identity,
		ECC_PhysicsBody,
		FCollisionShape::MakeCapsule(PickupTraceRadius, PicupTraceCapsuleHalfHeight),
		Params
	);

	DrawDebugCapsule(GetWorld(), (Start + End) * 0.5f, PicupTraceCapsuleHalfHeight ,PickupTraceRadius, FQuat::Identity,
		bHit ? FColor::Green : FColor::Red, false, 1.0f, 0, 1.5f);
	
	if (bHit && Hit.GetComponent() && Hit.GetComponent()->IsSimulatingPhysics())
	{
		AActor* HitActor = Hit.GetActor();
		if (HitActor)
		{
			if (!HasAuthority())
			{
				ServerRPC_HandlePickup(HitActor, true);
			}
			else
			{
				PickupObject(HitActor);
			}
		}
	}
}

void ALNCharacter::PickupObject(AActor* TargetActor)
{
	if (!TargetActor || !HasAuthority())	return;
	
	// 서버에서만 CarriedObject 설정 (이것이 복제되면서 OnRep이 호출됨)
	CarriedObject = TargetActor;
	bIsCarry = true;

	// 서버에서도 실제 Attach 수행
	AttachCarriedObject();
	
	UE_LOG(LogTemplateCharacter, Log, TEXT("[Server] PickupObject: %s"), *TargetActor->GetName());
}

void ALNCharacter::ReleasePickupObject()
{
	if (!CarriedObject || !HasAuthority())	return;

	// 서버에서도 실제 Detach 수행
	DetachCarriedObject();

	// CarriedObject를 nullptr로 설정 (이것이 복제되면서 OnRep이 호출됨)
	CarriedObject = nullptr;
	bIsCarry = false;

	UE_LOG(LogTemplateCharacter, Log, TEXT("[Server] ReleasePickupObject"));
}

// OnRep 함수: CarriedObject가 변경될 때 클라이언트에서 호출됨
void ALNCharacter::OnRep_CarriedObject()
{
	// 이전에 들고 있던 물체가 있으면 먼저 Detach
	if (LastCarriedObject && !CarriedObject)
	{
		DetachCarriedObject();
		UE_LOG(LogTemplateCharacter, Log, TEXT("[Client] OnRep_CarriedObject: Detached %s"), *LastCarriedObject->GetName());
	}
	
	// 새로 들 물체가 있으면 Attach
	if (CarriedObject)
	{
		AttachCarriedObject();
		UE_LOG(LogTemplateCharacter, Log, TEXT("[Client] OnRep_CarriedObject: Attached %s"), *CarriedObject->GetName());
	}
	
	// 현재 값을 LastCarriedObject에 저장
	LastCarriedObject = CarriedObject;
}

// 실제 물리적 Attach 로직 (서버와 클라이언트 모두에서 실행)
void ALNCharacter::AttachCarriedObject()
{
	if (!CarriedObject)	return;

	UPrimitiveComponent* PrimComp = Cast<UPrimitiveComponent>(CarriedObject->GetRootComponent());
	
	if (PrimComp && PrimComp->IsSimulatingPhysics())
	{
		// 캐릭터와 충돌 방지
		HeldItemCollisionType = PrimComp->GetCollisionEnabled();
		PrimComp->IgnoreActorWhenMoving(this, true);
		PrimComp->SetSimulatePhysics(false);
		PrimComp->SetEnableGravity(false);
        PrimComp->SetCollisionEnabled(ECollisionEnabled::NoCollision);

		// 들고있을 오브젝트 크기 기반 거리 계산
		FVector Origin, Extent;
		CarriedObject->GetActorBounds(true, Origin, Extent);
		float ObjectSize = Extent.Size();
		float Distance = FMath::Clamp(ObjectSize * 0.5f, 40.f, 120.f);

		FVector SocketLocation = GetMesh()->GetSocketLocation("PickupSocket");
		FVector AttachLocation = SocketLocation + GetActorForwardVector() * Distance;

		CarriedObject->SetActorLocation(AttachLocation);
		CarriedObject->AttachToComponent(
			GetMesh(),
			FAttachmentTransformRules::KeepWorldTransform,
			TEXT("PickupSocket")
		);
		
		UE_LOG(LogTemplateCharacter, Log, TEXT("[%s] AttachCarriedObject: %s"), 
			HasAuthority() ? TEXT("Server") : TEXT("Client"), 
			*CarriedObject->GetName());
	}
}

// 실제 물리적 Detach 로직 (서버와 클라이언트 모두에서 실행)
void ALNCharacter::DetachCarriedObject()
{
	// LastCarriedObject를 사용 (OnRep에서 설정됨)
	AActor* ObjectToDetach = LastCarriedObject ? LastCarriedObject : CarriedObject;

	if (!ObjectToDetach)	return;

	if (UPrimitiveComponent* PrimComp = Cast<UPrimitiveComponent>(ObjectToDetach->GetRootComponent()))
	{
		PrimComp->SetCollisionEnabled(HeldItemCollisionType);
		PrimComp->IgnoreActorWhenMoving(this, false);
		PrimComp->SetSimulatePhysics(true);
		PrimComp->SetEnableGravity(true);
	}

	ObjectToDetach->DetachFromActor(FDetachmentTransformRules::KeepWorldTransform);
	ObjectToDetach->SetOwner(nullptr);

	UE_LOG(LogTemplateCharacter, Log, TEXT("[%s] DetachCarriedObject: %s"), 
		HasAuthority() ? TEXT("Server") : TEXT("Client"),
		*ObjectToDetach->GetName());
}

오브젝트가 Pickup 되고난 후 클라이언트에 복제가 되지 않은 이유론 클라이언트에서 CarriedObject 가 복제는 되나 Attach/Detach가 서버에서만 실행되는 문제가 있었음.

따라서 OnRep 함수를 위처럼 구현하여 클라이언트에서도 CarriedObject가 Attach/Detach되도록 구현하였다.

콜리전 설정 순서를 Nocollision 으로 설정 후 Physics 설정을 수정하여서 위처럼 경고 메세지가 출력되었었다.

Nocollision 설정하는 순서를 위처럼 변경하여주면 해결된다!.

PickUp 기능

Turtle_Jun — Mon, 10 Nov 2025 21:17:00 +0900

트러블 슈팅

픽업 시 들고있는 오브젝트가 리플리케이션 안되는 문제
콜리전 프리셋을 에디터에서 수정시 픽업이 되지 않는 문제

해결 방안 모색

콜리전 프로파일 채널을 추가하고 리플리케이션 설정을 블루프린트 액터를 생성하여 새로 구현해볼 예정

최종 팀 프로젝트 Pickup 기능 구현 -2

Turtle_Jun — Fri, 7 Nov 2025 22:22:00 +0900

2025.11.06 - [트러블 슈팅] - 최종 팀 프로젝트 Pickup 기능 구현

최종 팀 프로젝트 Pickup 기능 구현

2025.11.05 - [언리얼 팀프로젝트] - 최종 팀 프로젝트 -캐릭터 모듈 컴포넌트 구현 최종 팀 프로젝트 -캐릭터 모듈 컴포넌트 구현2025.11.04 - [언리얼 팀프로젝트] - 최종 팀프로젝트 - 캐릭터 기본 애

unrealstudyhome.tistory.com

오늘은 PickUp 기능을 코드로 구현해보았는데 이전에 월드 다른 좌표에 붙는 문제는 해결하였으나 오브젝트가 붙는게 뭔가 자연스럽지 못한 문제가 있어서 수정 후 해당 글을 추가 하도록 할 예정

최종 팀 프로젝트 Pickup 기능 구현

Turtle_Jun — Thu, 6 Nov 2025 22:30:34 +0900

2025.11.05 - [언리얼 팀프로젝트] - 최종 팀 프로젝트 -캐릭터 모듈 컴포넌트 구현

최종 팀 프로젝트 -캐릭터 모듈 컴포넌트 구현

2025.11.04 - [언리얼 팀프로젝트] - 최종 팀프로젝트 - 캐릭터 기본 애니메이션 구현 최종 팀프로젝트 - 캐릭터 기본 애니메이션 구현2025.11.03 - [언리얼 팀프로젝트] - 최종 팀프로젝트 - 캐릭터 구현

unrealstudyhome.tistory.com

(1) 언리얼 엔진 5에서 물리적 객체를 운반하는 방법 - YouTube

위 영상을 참고하여 Pickup 기능을 구현해보았는데.. Pyshics Handle 에 붙여지는게 원하는곳에 안 붙는 버그가 있다.

해당 이미지 처럼 큐브가 캐릭터의 소켓에 안붙고.. 캐릭터 시작점에 붙는 문제가 있다..

Handle 컴포넌트가 캐릭터 위치에 붙지 않아서 그런거같은데 Attach 해봐도 동일한 문제가 있어서 고민을 해봐야할 것 같다.

최종 팀 프로젝트 -캐릭터 모듈 컴포넌트 구현

Turtle_Jun — Wed, 5 Nov 2025 23:29:51 +0900

2025.11.04 - [언리얼 팀프로젝트] - 최종 팀프로젝트 - 캐릭터 기본 애니메이션 구현

최종 팀프로젝트 - 캐릭터 기본 애니메이션 구현

2025.11.03 - [언리얼 팀프로젝트] - 최종 팀프로젝트 - 캐릭터 구현 (이동/앉기/달리기) 최종 팀프로젝트 - 캐릭터 구현 (이동/앉기/달리기)캐릭터 이동/앉기/달리기를 구현해놓은 상태로 애님 블루

unrealstudyhome.tistory.com

같은 팀원인 재근님의 이전 프로젝트에서 구현한 내용을 공유 받아 본 프로젝트 캐릭터와 연동을 하였다.

- CharacterPartType.h

#pragma once

#include "CoreMinimal.h"
#include "Net/Serialization/FastArraySerializer.h"
#include "CharacterPartType.generated.h"

class UMJ_CharacterPartComponent;
class USkeletalMeshComponent;
class USkeletalMesh;


// 파츠 슬롯 정의 (모자, 상의, 하의, 몸통 등)
UENUM(BlueprintType)
enum class ECharacterPartSlot : uint8
{
	None,
	Top,	//	상의
	Dress,	//	원피스
	Hat,	//	모자
	Hair,	//	머리
	Gloves,	//	장갑
	Glasses,	//	안경
	Eyeballs,	//	눈
	Eyebrows,	//	눈썹
	Beard,	//	수염
	Shoes,	//	신발
	Bottoms,	//	하의
	Body,	//	몸 (피부 색)
	Bag	//	가방
};

/*
 * 단일 파츠 정보 구조체 (어떤 슬롯에 어떤 메시를 쓸지 결정)
 */
USTRUCT(BlueprintType)
struct FCharacterPart
{
	GENERATED_BODY()

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cosmetic")
	ECharacterPartSlot Slot = ECharacterPartSlot::None;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cosmetic")
	TObjectPtr<USkeletalMesh> Mesh = nullptr;
};

/*
 *	개별 적용된 파츠 배열의 개별 항목
 */
USTRUCT()
struct FAppliedCharacterPartEntry : public FFastArraySerializerItem
{
	GENERATED_BODY()

	// 적용된 파츠의 데이터(부위, 메시) / 네트워크 복제 ㅇ
	UPROPERTY()
	FCharacterPart Part;

	// 런타임에 생성된 스켈레탈 메쉬 컴포넌트 포인터	/ 복제 X
	UPROPERTY(NotReplicated)
	TObjectPtr<USkeletalMeshComponent> SpawnedComponent = nullptr;
};

// 캐릭터에 적용된 모든 파츠 목록을 관리하는 구조체 / 네트워크 최적화
USTRUCT()
struct FCharacterPartList : public FFastArraySerializer
{
	GENERATED_BODY()

public:
	FCharacterPartList() : OwnerComponent(nullptr)
	{
	}
	FCharacterPartList(UMJ_CharacterPartComponent* InOwnerComponent) : OwnerComponent(InOwnerComponent)
	{
	}

	void PreReplicateRemove(const TArrayView<int32> RemoveIndices, int32 FinalSize);
	void PostReplicatedAdd(const TArrayView<int32> AddIndices, int32 FinalSize);
	void PostReplicatedChange(const TArrayView<int32> ChangeIndices, int32 FinalSize);

	bool NetDeltaSerialize(FNetDeltaSerializeInfo& DeltaParms)
	{
		return FastArrayDeltaSerialize<FAppliedCharacterPartEntry, FCharacterPartList>(Entries,DeltaParms, *this);
	}

	// 스켈레탈 메쉬 컴포넌트 생성 후 부착하는 함수
	void SpawnMeshForEntry(FAppliedCharacterPartEntry& Entry);
	// 스켈레탈 메쉬 컴포넌트 제거하는 함수
	void DestroyMeshForEntry(FAppliedCharacterPartEntry& Entry);
	
	UPROPERTY()
	TArray<FAppliedCharacterPartEntry> Entries;

	UPROPERTY(NotReplicated)
	TObjectPtr<UMJ_CharacterPartComponent> OwnerComponent;
};

// 템플릿 특수화
template<>
struct TStructOpsTypeTraits<FCharacterPartList> : public TStructOpsTypeTraitsBase2<FCharacterPartList>
{
	enum {	WithNetDeltaSerializer = true	};
};

- CharacterPartType.cpp

#include "CharacterPartType.h"
#include "MJ_CharacterPartComponent.h"
#include "Components/SkeletalMeshComponent.h"

//  서버에서 파츠 제거되었다는 정보 도착시 클라이언트에서 호출
void FCharacterPartList::PreReplicateRemove(const TArrayView<int32> RemoveIndices, int32 FinalSize)
{
    for (const int32 Index : RemoveIndices)
    {
       FAppliedCharacterPartEntry& Entry = Entries[Index];
       DestroyMeshForEntry(Entry);
    }
}

//  서버에서 새로운 파츠가 추가 되었다는 정보 도착시 클라이언트에서 호출
void FCharacterPartList::PostReplicatedAdd(const TArrayView<int32> AddIndices, int32 FinalSize)
{
    for (const int32 Index : AddIndices)
    {
       FAppliedCharacterPartEntry& Entry = Entries[Index];
       SpawnMeshForEntry(Entry);
    }
}

//  서버에서 기존 파츠의 정보가 변경될 때 클라에서 호출
void FCharacterPartList::PostReplicatedChange(const TArrayView<int32> ChangeIndices, int32 FinalSize)
{
    for (const int32 Index : ChangeIndices)
    {
       FAppliedCharacterPartEntry& Entry = Entries[Index];
       DestroyMeshForEntry(Entry);
       SpawnMeshForEntry(Entry);
    }
}

//  파츠 데이터를 기반으로 실제 스켈레탈 메시 컴포넌트를 생성하고 캐릭터에 부착
void FCharacterPartList::SpawnMeshForEntry(FAppliedCharacterPartEntry& Entry)
{
    if (!IsValid(OwnerComponent) || !IsValid(Entry.Part.Mesh)) return;

    USkeletalMeshComponent* ParentMesh = OwnerComponent->GetParentMeshComponent();
    if (!IsValid(ParentMesh)) return;  

    AActor* OwnerActor = OwnerComponent->GetOwner();

    FName ComponentName = *FString::Printf(TEXT("CosmeticPart_%s"), *UEnum::GetValueAsString(Entry.Part.Slot));
    USkeletalMeshComponent* NewPartComponent = NewObject<USkeletalMeshComponent>(OwnerActor, ComponentName);

    NewPartComponent->SetupAttachment(ParentMesh);

    NewPartComponent->SetSkeletalMesh(Entry.Part.Mesh);

    // 모든 파츠 컴포넌트가 부모(몸통)의 애니를 그대로 따라가도록 설정
    NewPartComponent->SetLeaderPoseComponent(ParentMesh);

    NewPartComponent->RegisterComponent();

    Entry.SpawnedComponent = NewPartComponent;
}

// 파츠 제거될때 생성한 스켈레탈 메쉬를 안전하게 제거
void FCharacterPartList::DestroyMeshForEntry(FAppliedCharacterPartEntry& Entry)
{
    if (IsValid(Entry.SpawnedComponent))
    {
       Entry.SpawnedComponent->DestroyComponent();
       Entry.SpawnedComponent = nullptr;
    }
}

- MJ_CharacterPartComponent.h

#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "CharacterPartType.h"
#include "MJ_CharacterPartComponent.generated.h"


UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class MIJUNG_API UMJ_CharacterPartComponent : public UActorComponent
{
	GENERATED_BODY()

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

	virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;

	/*
	 * 지정된 파츠를 캐릭터에 장착하거나 교체 / 서버에서만 호출
	 * 장착할 파츠의 정보(부위, 메시)
	 */
	UFUNCTION(BlueprintCallable, Category = "Cosmetic", meta = (CallInEditor = "true"))
	void SetCharacterPart(const FCharacterPart& NewPart);

	//	해당 컴포넌트가 제어해야할 주 스켈레탈 메쉬를 반환(몸통)
	// 해당 스켈레탈 메쉬를 기반으로 파츠들이 붙으며 애니도 동기화됨
	USkeletalMeshComponent* GetParentMeshComponent() const;
	
private:

	// 캐릭터에 적용된 모든 파츠 목록
	UPROPERTY(Replicated, Transient)
	FCharacterPartList AppliedCharacterPartList;
		
};

- MJ_CharacterPartComponent.cpp


#include "Character/MJ_CharacterPartComponent.h"

#include "GameFramework/Character.h"
#include "Net/UnrealNetwork.h"

UMJ_CharacterPartComponent::UMJ_CharacterPartComponent()
	: AppliedCharacterPartList(this)	
{
	SetIsReplicatedByDefault(true);
}

void UMJ_CharacterPartComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);

	DOREPLIFETIME(ThisClass, AppliedCharacterPartList);	//적용된 파츠들 네트워크 복제
}


void UMJ_CharacterPartComponent::SetCharacterPart(const FCharacterPart& NewPart)
{
	if (!GetOwner() || !GetOwner()->HasAuthority())
		return;

	// 기존 슬롯 제거
	for (auto It = AppliedCharacterPartList.Entries.CreateIterator(); It; ++It)
	{
		if (It->Part.Slot == NewPart.Slot)
		{
			AppliedCharacterPartList.DestroyMeshForEntry(*It);
			It.RemoveCurrent();
			AppliedCharacterPartList.MarkArrayDirty();
			break;
		}
	}

	if (!IsValid(NewPart.Mesh)) return;

	// 새 엔트리 추가
	FAppliedCharacterPartEntry& NewEntry = AppliedCharacterPartList.Entries.AddDefaulted_GetRef();
	NewEntry.Part = NewPart;
	AppliedCharacterPartList.SpawnMeshForEntry(NewEntry);
	AppliedCharacterPartList.MarkItemDirty(NewEntry);
}

USkeletalMeshComponent* UMJ_CharacterPartComponent::GetParentMeshComponent() const
{
	if (ACharacter* Char = Cast<ACharacter>(GetOwner()))
	{
		return Char->GetMesh();
	}
	return nullptr;
}

이전 캐릭터 코드에서 위 컴포넌트를 사용하기 위해 아래처럼 코드 내용을 추가하면 된다.

- MJCharacter.h

// MJCharacter.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "CharacterPartComponent.h" // 추가
#include "CharacterPartType.h"      // 추가
#include "MJCharacter.generated.h"

class USpringArmComponent;
class UCameraComponent;
class UInputMappingContext;
class UInputAction;
class UAnimMontage;
struct FInputActionValue;

DECLARE_LOG_CATEGORY_EXTERN(LogTemplateCharacter, Log, All);

UCLASS()
class MIJUNG_API AMJCharacter : public ACharacter
{
	GENERATED_BODY()

public:
	AMJCharacter();

protected:

	//-----------------------------------------------------
	// ✅ 코스메틱 시스템
	//-----------------------------------------------------
public:
	// 캐릭터 외형 파츠 관리용 컴포넌트
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Cosmetic")
	UCharacterPartComponent* CharacterPartComponent;

	// 서버에서 새로운 파츠 장착 요청을 처리 (리슨 서버용)
	UFUNCTION(Server, Reliable)
	void Server_EquipPart(const FCharacterPart& NewPart);

	// 블루프린트 또는 UI에서 호출 (클라이언트에서 실행)
	UFUNCTION(BlueprintCallable, Category = "Cosmetic")
	void EquipPart(const FCharacterPart& NewPart);

	//-----------------------------------------------------
	// 기존 캐릭터 관련 변수/함수
	//-----------------------------------------------------


	// ... (기존 입력 액션들 그대로 유지)
	

};

- MJCharacter.cpp

// MJCharacter.cpp

#include "Character/MJCharacter.h"
#include "CharacterPartComponent.h"
#include "CharacterPartType.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/SpringArmComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
#include "Net/UnrealNetwork.h"

DEFINE_LOG_CATEGORY(LogTemplateCharacter);

AMJCharacter::AMJCharacter()
{
	bReplicates = true;
	GetCharacterMovement()->SetIsReplicated(true);

	// ✅ 코스메틱 시스템 컴포넌트 생성
	CharacterPartComponent = CreateDefaultSubobject<UCharacterPartComponent>(TEXT("CharacterPartComponent"));
	AddOwnedComponent(CharacterPartComponent);

	// ✅ 리슨서버/클라 환경에서만 카메라 생성
	if (!IsRunningDedicatedServer())
	{
		CameraArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraArm"));
		CameraArm->SetupAttachment(RootComponent);
		CameraArm->TargetArmLength = 400.0f;
		CameraArm->bUsePawnControlRotation = true;

		FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
		FollowCamera->SetupAttachment(CameraArm, USpringArmComponent::SocketName);
		FollowCamera->bUsePawnControlRotation = false;
	}

	bIsSprinting = false;
}

void AMJCharacter::BeginPlay()
{
	Super::BeginPlay();

	// ✅ 초기 외형 세팅 (서버에서만)
	if (HasAuthority() && CharacterPartComponent)
	{
		FCharacterPart BaseBody;
		BaseBody.Slot = ECharacterPartSlot::Body;
		BaseBody.Mesh = LoadObject<USkeletalMesh>(nullptr, TEXT("/Game/Characters/Parts/Meshes/SK_Body_Default.SK_Body_Default"));
		if (BaseBody.Mesh)
		{
			CharacterPartComponent->SetCharacterPart(BaseBody);
		}
	}
}

void AMJCharacter::EquipPart(const FCharacterPart& NewPart)
{
	// 클라이언트 → 서버로 요청
	if (!HasAuthority())
	{
		Server_EquipPart(NewPart);
	}
	else
	{
		if (CharacterPartComponent)
		{
			CharacterPartComponent->SetCharacterPart(NewPart);
		}
	}
}

void AMJCharacter::Server_EquipPart_Implementation(const FCharacterPart& NewPart)
{
	if (!IsValid(CharacterPartComponent)) return;
	CharacterPartComponent->SetCharacterPart(NewPart);
}

void AMJCharacter::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);
	DOREPLIFETIME(ThisClass, bIsSprinting);
}

void AMJCharacter::Move(const FInputActionValue& Value)
{
	// 기존 코드 그대로 유지
}

void AMJCharacter::Look(const FInputActionValue& Value)
{
	// 기존 코드 그대로 유지
}

// 나머지 기존 Sprint, Crouch, Interact 로직 그대로 유지