📅 2026-05-22

개인적으로 캠프에서 만난 다양한 분들과 튜터님 매니저님들 너무 다 좋다. 커리큘럼도 솔직히 만족스러웠다. 그런데 아예 개발과 연이 없던 분들도 오셔서 같이 수업받기 때문에 Git사용법이나 협업 관련된 수업을 2시간하고 끝내는게 아니라 더 많은 시간을 투자해주시는게 좋을 것 같다. Git이라는게 원래 사용법도 막연해서 어려운데 갑자기 협업이라는게 하루아침에 뚝딱 되는것도 아니고 많이 난감했다.

팀(협업)으로 TextRPG 만들기

대략적으로 이런 형태로 만들기로 했다. 내부 함수를 어떤식으로 만드는지는 유관끼리 얘기하기로 했고 나는 LoggingManager를 담당하게 됐다.

📅 2026-05-21

프로젝트가 끝났다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조 -> 일신상의 이유로 Perforce로 변경

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

프로젝트 종료 회고록

1. 프로젝트 개요

• 프로젝트명: 뱀파이어 서바이벌 류 게임 트레이싱
• 진행 기간: 26.05.11 ~ 26.05.21
• 팀 인원: 송용수, 최배성, 양석현, 정규상, 이정준, 임우현

2. 프로젝트 목표

목표

• 규상 : 언리얼 C++ 문법익숙해지기
• 용수 : 유니티 UI를 언리얼로 포팅 > MVP패턴 이용해서 모델/뷰 완벽하게 분리
• 배성 : 흘러가는 게임을 구성해보자. + 협업 스킬 레벨업
• 석현 : 협업 경험 + 언리얼 학습
• 정준 : 협업 경험 + 언리얼 학습
• 우현 : 협업 경험 + 언리얼, 게임개발과정 학습

주요 기능

용수

• 체력바
• 경험치바 material 애니메이션 구현
• 경험치/데미지 위젯구현 > 풀링으로 화면에 띄우는 것
• UIManager 경유 , 모델과 뷰 바인딩 자동화

배성

• 무기, 총알 등의 BaseClass 선언 > 확장성 확보 고려
• 컴포넌트를 사용해서 기능분리

석현

• 몬스터 class 구현하면서 확장성 고려

정준

• 플레이어 보유 장비 상태 관리
• 소유자 Actor > Enemy가 특정 조건 만족 시 아이템 드롭

규상

• PoolingManager 기반으로 액터 생성하는 기법
• 전체적인 Gamemode를 어떻게 사용해야하는지
• 협업할때 어떻게 해야하는지 (게임) 구체화

우현

• 캐릭터 MovementComponent C++로 구현
• 카메라arm 없이 달기 > arm 없으면 캐릭터 따라가기를 따로 구현해야함
• 8방향 BS 구현 > ABP 바인딩

사용 기술 스택

• Engine: UE 5.5.4 (강의 디폴트여서) / 5.7 컴파일 오래걸려서
• Language: C++, BP
• Version Control: Github -> Perforce\

3. 프로젝트 결과

미완료 또는 축소된 사항

용수

• 완전자동화 실패, 프레젠터 하드코딩 > 완벽한 MVP 패턴 구현 실패
• 언리얼 CommonUI+MVVM 같이 사용해야 시너지 있음 > 팀원들에게 MVVM 패턴 전파 해야함(커뮤니케이션 코스트 있어서 진행X)

배성

• AttackBaseComponent 현재 사양에서 필요없는데 포함되어있음
• ObjectPooling 적용X (둥근검, 짧은칼 지원안함)

석현

• SetActorLocation, MovementComponent 사용안함 > 확장에 어려움 발생
• EnemyClass를 확장성있게 만들지 못했다(상태머신 도입을 못했다.)

정준

• 패시브 장비 구현 못함
• 드랍 > Pooling 미적용 성능저하

규상

• 비동기 풀링 최적화 > Tick으로 하는게 더 좋다라는 ChatGPT의 의견 (왜인지는 모르나 .. 나중에 알아봐야함)
• 풀링매니저 > AActor말고 UObject로 구현했어야했다. 팀원들이 풀링인터페이스 적용하지 않은 이유
• 프리웜 타이밍 잡기가 애매했다. > EquipComponet 구현상 프리웜 하기가 어려웠다.
• 이미 아이템을 다 개발하고 나서 PoolingManager 개발이 완료되어서 적용하려면 리팩토링이 필요했음(소통문제)
• UI 풀링 따로 구현 > PoolingManger가 AActor Class를 부모로해서 못씀 > UI들은 WidgetClass를 부모로 해서 사용불가

우현

• 구현을 더 많이 했으면 좋았을텐데 범위가 좁았다.

4. 스프린트 운영 회고

잘된 점

용수

• 팀원들이 UI신경안쓰고 Delegate만 달아서 개발 가능하도록 하고 싶었고 어느정도 목표 달성
• UI Widget 디자이너탭 사용에 익숙해짐.

배성

• 무기 관련 클래스 확장성 잘 나눠서 구현이 쉽게 되어있음
• 급하게 추가한 soundplayersubsystem 블루프린트랑 사용하는 구조가 좋은듯

석현

• 위치고정을 사용한 넉백과 같은 힘을 주는 시스템 구현

정준

• Class별 Pool 분리된 것 사용하기 편함
• 반복 생성 객체 재사용 가능

규상

• Pooling 생각보다 잘 작동
• 협업시스템 인프라 구축 잘함

우현

• 팀원들이랑 친해져서 좋았따.
• 게임개발흐름을 직접적으로 볼수 있어 좋은 경험이였다 생각된다.

아쉬웠던 점

용수

• 언리얼 문법에 익숙하지 않아서 GC관련 디버깅에 문제가있었다. > 앞으로 언리얼C++ 리플렉션 시스템을 더 공부해야겠다.
• Delegate 필요 명세를 더 구체화하고 작업할 필요가 있었다. (기획문제)
• UI는 결국 BP 작업 필요 > BP로 작업해야할 것을 CPP로 작업한 부분들이 있음 > 익숙치 않아서 분리가 어려웟다.

배성

• 무기 설계 시 내부기능을 알아왔다면 설계를 더 잘할 수 있었을 것.
• 설계 후 구현에 시간이 과투자됐다. (설계가 잘 되어있었다면 더 빠르게 개발 가능했을 것)
• 리소스 에셋을 미리 디깅했었다면 역시 구현 속도가 빨랏을 것. > 트레이드오프가 잘 안됐다.

석현

• 더 많은 부분을 맡았으면 밀도있게 공부가 됐을 것 같은데 생각보다 시간이 많이 남았다.

정준

• 플레이어 스킬까지 구현인줄 알았는데 범위가 좁았음. > 아이템 틀만 구현하니 작업량이 부족했다.
• Delegate를 필요한곳에서 Broadcast했어야했는데 애매하게 했다.
• 패시브 아이템 미구현(시간부족)
• 작업량이 1/n이 안됐다.

규상

• spawner > 한번 만들어 봤어서 생각보다 구현 속도가 빨라서 이후 할게 많이 없었다.
• pooling > 개념이라 이해 하고 나서는 너무 쉬워서 구현/수정도 빨랐다. > 진짜 할게 많이 없었던 것 같다.
• 로딩화면 굳이라고 생각했지만 그래도 한번 해봤으면 좋았을 것 같다.

5. 팀 협업 회고

좋았던 협업 방식

• 개발 전 업무영역 분배하고 시작한 부분 좋았다.
• PR 코드리뷰 하는 것 좋았다.
• 다같이 마이크 키고 화면공유 상시로 되어있어서 커뮤니케이션에 도움이 많이 됐다.
• 브랜치 전략을 생각보다 잘 지켜주셨다.

개선이 필요한 부분

• 업무 분배 후 분배된 업무 영역이라는 울타리 때문에 조금더 적극적이지 못했던 것 같다. > 필요하다면 더 할 수 있었을 부분들이 확실히 있다.
• 작업 분배 시 1/n이었다면 좋았을 것 같다. -> 인원 설정 또한 기획 단계에서 정해졌어야 했는데 아쉽다.
• Perforce 작업/사용 전략을 좀 잡고가면 좋을것같다.

📅 2026-05-20

무한성이라고 불리던 스테이지를 일찍 탈출한 6명이서 사이드 프로젝트를 진행하기로 했다. 순전히 기능 공부를 위함이고 출시계획같은건 당연하게도 없다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조 -> 일신상의 이유로 Perforce로 변경

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

PoolingManager 최적화

기존구현

기존에는 액터 300개를 미리 생성해서 Pool에 넣어두고 가져왔다가 넣었다가 하는 식이었는데

로딩화면으로 최적화 할까 고민하다가 Tick에서 3초에 20개씩 생성 > 300개되면 스탑 되는 형식으로 최적화했다.

실제로 게임 시작 후 world time 00:01에서 잠깐 스로틀링 걸리던 문제가 해결됐다!

📅 2026-05-19

무한성이라고 불리던 스테이지를 일찍 탈출한 6명이서 사이드 프로젝트를 진행하기로 했다. 순전히 기능 공부를 위함이고 출시계획같은건 당연하게도 없다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조 -> 일신상의 이유로 Perforce로 변경

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

마무리 작업

오늘은 하루종일 게임 내 벨런싱이나 스프라이트 찍거나 게임모드 내에서 설정들을 미세 수정하는 작업들을 진행했다.

내일은 아마 풀링매니저 + 로딩화면을 통해 최적화를 진행해보려고한다.

📅 2026-05-18

무한성이라고 불리던 스테이지를 일찍 탈출한 6명이서 사이드 프로젝트를 진행하기로 했다. 순전히 기능 공부를 위함이고 출시계획같은건 당연하게도 없다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조 -> 일신상의 이유로 Perforce로 변경

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

Github -> Perforce 마이그레이션

계획 중 하나였던 9기의 모든 프로젝트를 하나의 Organization으로 관리하고 각 다른 팀의 PR과 코드를 볼 수 있게 하고싶었는데 LFS 대역폭이 너무 적어서 어떤 대체제가 있을지 찾던 중 Perforce 라는 걸 알게됐다.

Perforce는 Git과 비슷한 형상관리툴인데 다른점은 Github같이 플랫폼이 있어서 거기서 관리하는게 아니라 개인 서버 혹은 클라우드 저장소를 연결해서 사용한다.

Github

장점

• Branch 전략과 Workflow를 통해 코드 diff와 수정, 배포, 버저닝이 매우 간편
• 상대적으로 대중적이라(Perforce에 비해) 적응하기 쉬움

단점

• 언리얼에셋(uasset, umap 등) 수정 시 diff 감지를 못하고 최후에 merge된 파일로 덮어씀
• 자체 플랫폼의 클라우드 이용하기 때문에 결제 안하면 lfs 대역폭등 제한 사항이 많음

Perforce

장점

• 바이너리 그대로 업로드 가능
• 바이너리 에셋 수정 시 checkin/out 기능 제공 checkin시 Perfoce에서 파일을 Readonly로 바꿔서 작업하는 동안 다른 사람의 수정을 막을 수 있음 (기존 Github는 바이너리 에셋의 수정사항을 인식하지 못하고 가장 나중에 merge된 파일을 기준으로 덮어씀)
• Get Latest(pull) / Submit(push) 속도가 매우 빠름

단점

• 클라우드 서버 설정에 대한 진입장벽 남는 pc나 노트북이 있다면 하루종일 켜놔야하고 서버 초기 설정에 대한 진입장벽 있음 난 웹개발자였어서 쉽게 했지만 다른 사람들은... 잘 모르겠음
• 사용자 경험이 좋지않음 UI가 상상 이상으로 좋지않음 아래 이미지를 첨부할테지만 정말 각오해야함
• Git처럼 branch를 통해서 세세하게 관리하는 것이 아니라 이게 정말 관리가 될까? 싶음 이 또한 UI/UX가 좋지않아서 그렇다고 생각함.

Perforce 사용법에 대해서는 나중에 다시한번 작성할 예정

Gamemode 승리조건 추가

#include "Gamemode/VampireSurvivalGamemode.h"

#include "EngineUtils.h"
#include "DataAsset/RunConfigDataAsset.h"
#include "DataAsset/WaveDataAsset.h"
#include "Kismet/GameplayStatics.h"
#include "Spawner/EnemySpawner.h"

AVampireSurvivalGamemode::AVampireSurvivalGamemode()
{
}

void AVampireSurvivalGamemode::BeginPlay()
{
    Super::BeginPlay();
    AWorldSettings* WorldSettings = GetWorldSettings();

    if (bUseDebugTimeAcceleration)
    {
        WorldSettings->SetTimeDilation(30.0f);
    }

    for (TActorIterator<AEnemySpawner> It(GetWorld()); It; ++It)
    {
        EnemySpawner = *It;
        break;
    }

    StartRun();
}

void AVampireSurvivalGamemode::StartRun()
{
    if (!RunConfig)
    {
        UE_LOG(LogTemp, Warning, TEXT("RunConfig is not set."));
        return;
    }

    //Debug, Production duration set 및 판단
    RunDurationSeconds = bUseDebugDuration
                             ? RunConfig->DebugDurationSeconds
                             : RunConfig->ProductionDurationSeconds;

    ElapsedTime = 0.f;
    CurrentWave = nullptr;
    CurrentWaveIndex = INDEX_NONE;

    SetCurrentWave(FindWaveForElapsedTime(ElapsedTime));

    GetWorldTimerManager().SetTimer(
        RunTimerHandler,
        this,
        &AVampireSurvivalGamemode::UpdateRunTime,
        1.f,
        true
    );
}

void AVampireSurvivalGamemode::UpdateRunTime()
{
    ElapsedTime += 1.f;
    OnRunElapsedTimeChanged.Broadcast(ElapsedTime);

    if (ElapsedTime >= RunDurationSeconds)
    {
        EndRun();
        return;
    }

    SetCurrentWave(FindWaveForElapsedTime(ElapsedTime));
}

void AVampireSurvivalGamemode::EndRun()
{
    GetWorldTimerManager().ClearTimer(RunTimerHandler);

    if (EnemySpawner)
    {
        EnemySpawner->StopSpawning();
    }

    // 게임 종료
    SetGameCompletedState();

    UE_LOG(LogTemp, Warning, TEXT("Run ended."));
}

UWaveDataAsset* AVampireSurvivalGamemode::FindWaveForElapsedTime(float InElapsedTime) const
{
    if (!RunConfig)
    {
        return nullptr;
    }

    for (UWaveDataAsset* Wave : RunConfig->Waves)
    {
        if (!Wave)
        {
            continue;
        }

        if (InElapsedTime >= Wave->StartTime && InElapsedTime < Wave->EndTime)
        {
            return Wave;
        }
    }

    return nullptr;
}

void AVampireSurvivalGamemode::SetCurrentWave(UWaveDataAsset* NewWave)
{
    if (CurrentWave == NewWave)
    {
        return;
    }

    CurrentWave = NewWave;

    if (!CurrentWave)
    {
        return;
    }

    CurrentWaveIndex = CurrentWave->WaveIndex;

    UE_LOG(LogTemp, Warning, TEXT("Wave changed: %d"), CurrentWaveIndex);

    if (EnemySpawner)
    {
        EnemySpawner->SetElapsedTime(ElapsedTime);
        EnemySpawner->SetWaveData(CurrentWave);
        EnemySpawner->StartSpawning();
    }
}

void AVampireSurvivalGamemode::SetGameCompletedState()
{
    AWorldSettings* WorldSettings = GetWorldSettings();

    if (!bIsGameCompleted && ElapsedTime >= 1800.f)
    {
        bIsGameCompleted = true;

        OnIsGameCompletedState.Broadcast(bIsGameCompleted);
        UGameplayStatics::SetGamePaused(GetWorld(), true);

    }
}

📅 2026-05-14

무한성이라고 불리던 스테이지를 일찍 탈출한 6명이서 사이드 프로젝트를 진행하기로 했다. 순전히 기능 공부를 위함이고 출시계획같은건 당연하게도 없다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

Enemy Spawn Object Pooling 구조로 바꾸기

이번 작업에서는 기존 Enemy 스폰 방식을 SpawnActor / Destroy 중심 구조에서 Object Pooling 기반 구조로 전환했다.

Vampire Survivors류 게임은 짧은 시간 안에 많은 적이 생성되고 사라진다. 이때 매번 Actor를 생성하고 파괴하면 성능 비용이 커질 수 있다.

그래서 Enemy가 죽었을 때 바로 Destroy()하지 않고, 비활성화한 뒤 풀에 반환하고, 다음 스폰 때 다시 꺼내 쓰는 구조를 추가했다.

기존 구조의 문제

기존 Enemy 흐름은 단순했다.

1. Enemy Spawn
2. SpawnedEnemiesList에 등록
3. Enemy 사망
4. Destroy() 호출
5. CleanupInvalidEnemies()에서 !IsValid(Enemy) 기준으로 리스트 정리

기존에는 Actor가 죽으면 Destroy되었기 때문에 IsValid()만으로도 리스트 정리가 가능했다.

하지만 풀링 구조에서는 Enemy가 죽어도 Actor가 파괴되지 않는다.

대신 다음과 같은 상태가 된다.

• Actor는 여전히 존재함
• IsValid(Enemy) == true
• 화면에서는 숨김 처리됨
• Collision 비활성화
• Tick 비활성화
• Pool의 Idle 상태로 들어감

즉 기존처럼 !IsValid(Enemy)만 검사하면, 이미 죽어서 풀에 들어간 Enemy가 SpawnedEnemiesList에 계속 남는다.

나중에 리스트 기반으로 살아있는 적 수를 계산하거나 Wave 진행 조건을 판단하면, 죽은 Enemy도 살아있는 Enemy처럼 카운트될 수 있다.

이번 변경의 핵심은 이 문제를 해결하는 것이었다.

PoolSubsystem 추가

먼저 Actor Pool을 관리할 UPoolSubsystem을 추가했다.

PoolSubsystem은 UWorldSubsystem으로 구현했다. 그래서 GameMode나 Spawner에 컴포넌트처럼 붙이지 않는다.

필요한 곳에서 다음처럼 가져와 사용한다.

UPoolSubsystem* PoolSubsystem = GetWorld()->GetSubsystem<UPoolSubsystem>();

풀은 ActorClass 기준으로 관리한다.

USTRUCT()
struct FActorPool
{
    GENERATED_BODY()

    UPROPERTY()
    TArray<TObjectPtr<AActor>> IdlePool;
};

UPROPERTY()
TMap<TSubclassOf<AActor>, FActorPool> IdlePools;

즉 BP_EnemyBase_C 풀, 다른 Enemy Blueprint 풀을 각각 따로 관리할 수 있다.

PrewarmPool

PrewarmPool()은 게임 시작 시 특정 ActorClass를 미리 생성해 IdlePool에 넣는 함수다.

void UPoolSubsystem::PrewarmPool(TSubclassOf<AActor> ActorClass, int32 Count)
{
    if (!ActorClass || Count <= 0 || !GetWorld())
    {
        return;
    }

    FActorPool& Pool = IdlePools.FindOrAdd(ActorClass);

    for (int32 i = 0; i < Count; ++i)
    {
        FActorSpawnParameters SpawnParams;
        SpawnParams.SpawnCollisionHandlingOverride =
            ESpawnActorCollisionHandlingMethod::AlwaysSpawn;

        AActor* Actor = GetWorld()->SpawnActor<AActor>(
            ActorClass,
            FVector::ZeroVector,
            FRotator::ZeroRotator,
            SpawnParams
        );

        if (!Actor)
        {
            UE_LOG(LogTemp, Warning, TEXT("[Pool] Prewarm spawn failed: %s"), *ActorClass->GetName());
            continue;
        }

        PrepareActorForPool(Actor);
        Pool.IdlePool.Add(Actor);
    }

    UE_LOG(LogTemp, Warning, TEXT("[Pool] Prewarm %s / Available: %d"),
        *ActorClass->GetName(),
        Pool.IdlePool.Num());
}

여기서 중요한 부분은 AlwaysSpawn이다.

Prewarm 시점에는 Actor를 생성한 뒤 바로 숨기고 Collision을 끌 것이기 때문에, 스폰 위치 충돌 때문에 생성이 실패할 필요가 없다.

SpawnParams.SpawnCollisionHandlingOverride =
    ESpawnActorCollisionHandlingMethod::AlwaysSpawn;

GetActorFromPool

Enemy를 스폰할 때는 직접 SpawnActor하지 않고 PoolSubsystem에서 Actor를 꺼낸다.

AActor* UPoolSubsystem::GetActorFromPool(TSubclassOf<AActor> ActorClass, const FTransform& SpawnTransform)
{
    if (!ActorClass || !GetWorld())
    {
        return nullptr;
    }

    FActorPool& Pool = IdlePools.FindOrAdd(ActorClass);

    AActor* Actor = nullptr;

    while (Pool.IdlePool.Num() > 0)
    {
        Actor = Pool.IdlePool.Pop();

        if (IsValid(Actor))
        {
            break;
        }

        Actor = nullptr;
    }

    if (!Actor)
    {
        Actor = GetWorld()->SpawnActor<AActor>(ActorClass, SpawnTransform);
    }

    if (!Actor)
    {
        return nullptr;
    }

    PrepareActorForUse(Actor, SpawnTransform);

    UE_LOG(LogTemp, Warning, TEXT("[Pool] Get %s / Available: %d / Active: %d"),
        *ActorClass->GetName(),
        Pool.IdlePool.Num(),
        IdlePools.Num());

    return Actor;
}

흐름은 다음과 같다.

1. IdlePool에 남은 Actor가 있으면 꺼낸다.
2. 유효하지 않은 Actor면 버린다.
3. IdlePool이 비어 있으면 새로 Spawn한다.
4. Actor를 사용할 수 있는 상태로 전환한다.

즉 PrewarmCount는 최대 제한이 아니라 “미리 만들어둘 개수”다.

예를 들어 PrewarmCount = 300인데 동시에 301번째 Enemy가 필요하면, 301번째는 그 순간 새로 Spawn된다. 이후 죽으면 다시 Pool에 들어가므로 Pool 크기는 301개까지 늘어날 수 있다.

ReturnActorToPool

Enemy가 죽으면 Destroy하지 않고 Pool로 반환한다.

void UPoolSubsystem::ReturnActorToPool(AActor* Actor)
{
    if (!IsValid(Actor))
    {
        return;
    }

    PrepareActorForPool(Actor);

    IdlePools.FindOrAdd(Actor->GetClass()).IdlePool.Add(Actor);
}

Actor를 Pool에 넣기 전에는 비활성 상태로 만든다.

void UPoolSubsystem::PrepareActorForPool(AActor* Actor)
{
    if (!IsValid(Actor))
    {
        return;
    }

    if (IPoolable* Poolable = Cast<IPoolable>(Actor))
    {
        Poolable->ReturnToPool();
    }

    Actor->SetActorHiddenInGame(true);
    Actor->SetActorEnableCollision(false);
    Actor->SetActorTickEnabled(false);
}

반대로 Pool에서 꺼낼 때는 다시 활성화한다.

void UPoolSubsystem::PrepareActorForUse(AActor* Actor, const FTransform& SpawnTransform)
{
    if (!IsValid(Actor))
    {
        return;
    }

    Actor->SetActorTransform(SpawnTransform);
    Actor->SetActorHiddenInGame(false);
    Actor->SetActorEnableCollision(true);
    Actor->SetActorTickEnabled(true);

    if (IPoolable* Poolable = Cast<IPoolable>(Actor))
    {
        Poolable->GetFromPool();
    }
}

IPoolable 인터페이스

PoolSubsystem은 모든 Actor의 내부 상태를 알 수 없다.

Enemy는 풀에서 나올 때 체력을 초기화해야 하고, 접촉 데미지 대상 목록도 비워야 한다. Projectile은 Projectile 나름의 초기화가 필요할 수 있다.

그래서 풀링 대상 Actor가 직접 초기화 로직을 구현할 수 있도록 IPoolable 인터페이스를 추가했다.

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

class VAMPIRESURVIVAL_API IPoolable
{
    GENERATED_BODY()

public:
    virtual void GetFromPool()
        PURE_VIRTUAL(IPoolable::GetFromPool,);

    virtual void ReturnToPool()
        PURE_VIRTUAL(IPoolable::ReturnToPool,);
};

이제 PoolSubsystem은 Actor가 IPoolable이면 다음 두 타이밍에 알려준다.

• Pool에서 꺼낼 때: GetFromPool()
• Pool로 반환할 때: ReturnToPool()

PoolableComponent 추가

풀링 구조에서 중요한 문제는 “Actor가 유효한가?”와 “게임상 살아있는가?”가 다르다는 점이다.

풀에 들어간 Enemy는 여전히 유효하다.

IsValid(Enemy) == true

하지만 게임상으로는 죽은 Enemy다.

그래서 별도의 상태값이 필요했다. 이를 위해 PoolableComponent를 추가했다.

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class VAMPIRESURVIVAL_API UPoolableComponent : public UActorComponent
{
    GENERATED_BODY()

public:
    UPoolableComponent();

    void SetPoolStatus(bool Status);
    bool GetPoolStatus() const;

protected:
    bool isIdle = true;
};

bool UPoolableComponent::GetPoolStatus() const
{
    return isIdle;
}

void UPoolableComponent::SetPoolStatus(bool Status)
{
    isIdle = Status;
}

현재는 bool로 idle 상태만 관리한다.

• true: Pool 안에 있음
• false: 현재 사용 중

나중에는 이름을 IsIdle() / SetIdle()처럼 바꾸면 더 읽기 좋아질 수 있다.

EnemyBase 변경

EnemyBase는 이제 IPoolable을 구현한다.

class VAMPIRESURVIVAL_API AEnemyBase : public ACharacter, public IHitable, public IPoolable

그리고 PoolableComponent를 가진다.

UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Enemy|Component")
TObjectPtr<UPoolableComponent> PoolableComponent;

생성자에서는 컴포넌트를 생성한다.

PoolableComponent = CreateDefaultSubobject<UPoolableComponent>(TEXT("PoolableComponent"));

Death에서 Destroy 대신 Pool 반환

기존에는 Enemy가 죽으면 바로 Destroy()했다.

풀링 구조에서는 먼저 PoolSubsystem에 반환을 시도한다.

void AEnemyBase::Death()
{
    if (UWorld* World = GetWorld())
    {
        if (UPoolSubsystem* PoolSubsystem = World->GetSubsystem<UPoolSubsystem>())
        {
            PoolSubsystem->ReturnActorToPool(this);
            return;
        }
    }

    Destroy();
}

PoolSubsystem을 가져오지 못한 경우에는 fallback으로 Destroy()를 호출한다.

EnemyBase의 GetFromPool / ReturnToPool

Enemy가 Pool에서 다시 나올 때는 전투 상태를 초기화해야 한다.

void AEnemyBase::GetFromPool()
{
    ContactDamageTargets.Empty();

    if (PoolableComponent)
    {
        PoolableComponent->SetPoolStatus(false);
    }

    if (HitableComponent)
    {
        HitableComponent->Initialize(MaxHP);
    }

    TargetActor = UGameplayStatics::GetPlayerCharacter(GetWorld(), 0);
}

풀에서 나올 때 하는 일은 다음과 같다.

• 접촉 데미지 대상 목록 초기화
• idle 상태 해제
• 체력 재초기화
• 플레이어 타겟 재설정

반대로 Pool로 돌아갈 때는 임시 상태를 비운다.

void AEnemyBase::ReturnToPool()
{
    ContactDamageTargets.Empty();
    TargetActor = nullptr;

    if (PoolableComponent)
    {
        PoolableComponent->SetPoolStatus(true);

        UE_LOG(LogTemp, Warning, TEXT("Enemy Returned To Pool: %s"), *GetName());
    }
}

여기서 PoolableComponent의 상태를 idle로 바꾸는 것이 중요하다.

이 값은 나중에 SpawnedEnemiesList 정리에 사용된다.

EnemySpawner 변경

기존 EnemySpawner는 Enemy를 직접 Spawn했다.

AEnemyBase* SpawnedEnemy = GetWorld()->SpawnActor<AEnemyBase>(...);

이제는 PoolSubsystem에서 꺼내온다.

UPoolSubsystem* PoolSubsystem = GetWorld()->GetSubsystem<UPoolSubsystem>();
if (!PoolSubsystem)
{
    return;
}

AActor* PooledActor = PoolSubsystem->GetActorFromPool(
    EnemyData->EnemyClass,
    FTransform(FRotator::ZeroRotator, SpawnLocation)
);

AEnemyBase* SpawnedEnemy = Cast<AEnemyBase>(PooledActor);

여기서 중요한 점은 EnemyData->EnemyClass를 기준으로 Pool에서 꺼낸다는 것이다.

현재 프로젝트는 Bat, Slime 같은 Enemy 차이를 별도 ActorClass로 나누기보다 EnemyDataAsset으로 주입하는 구조다. 따라서 Pool에서 꺼낸 뒤에는 현재 EnemyData를 다시 적용한다.

if (SpawnedEnemy)
{
    SpawnedEnemy->InitializeFromData(EnemyData);
    SpawnedEnemiesList.AddUnique(SpawnedEnemy);

    UE_LOG(LogTemp, Warning, TEXT("SpawnedEnemiesList Count After Spawn: %d"), SpawnedEnemiesList.Num());
}

Add() 대신 AddUnique()를 사용한 이유는 풀링 구조에서는 같은 Actor가 여러 번 재사용되기 때문이다.

만약 정리 타이밍이 어긋나면 같은 Enemy Actor가 리스트에 중복 등록될 수 있다. AddUnique()는 이 문제를 막는 안전장치다.

SpawnedEnemiesList 정리 방식 변경

기존 정리 방식은 단순했다.

SpawnedEnemiesList.RemoveAll([](const TObjectPtr<AActor>& Enemy)
{
    return !IsValid(Enemy);
});

하지만 풀링 구조에서는 이 조건만으로 부족하다. 풀로 돌아간 Enemy는 여전히 유효하기 때문이다.

그래서 PoolableComponent의 idle 상태도 함께 확인한다.

void AEnemySpawner::CleanupInvalidEnemies()
{
    const int32 BeforeCount = SpawnedEnemiesList.Num();

    SpawnedEnemiesList.RemoveAll([](const TObjectPtr<AActor>& Enemy)
    {
        if (!IsValid(Enemy))
        {
            return true;
        }

        const UPoolableComponent* PoolableComponent = Enemy->FindComponentByClass<UPoolableComponent>();
        if (PoolableComponent && PoolableComponent->GetPoolStatus())
        {
            return true;
        }

        return false;
    });

    const int32 AfterCount = SpawnedEnemiesList.Num();

    UE_LOG(LogTemp, Warning, TEXT("Cleanup SpawnedEnemiesList: %d -> %d"), BeforeCount, AfterCount);
}

이제 제거 조건은 두 가지다.

1. Actor가 더 이상 유효하지 않다.
2. Actor는 유효하지만 Pool에 들어간 idle 상태다.

이 변경으로 SpawnedEnemiesList는 “현재 활성화된 Enemy 목록”에 가까운 의미를 갖게 된다.

Prewarm 위치 조정

처음에는 Wave가 바뀔 때마다 WaveData를 읽어서 필요한 EnemyClass들을 Prewarm하는 방식도 고려했다.

하지만 현재 프로젝트 구조에서는 대부분의 Enemy가 같은 BP_EnemyBase_C를 사용한다.

즉 Bat, Slime, Skeleton이 서로 다른 ActorClass가 아니라 같은 EnemyBase Blueprint를 공유하고, 실제 차이는 EnemyDataAsset으로 적용된다.

그래서 Wave마다 Prewarm할 필요가 없다.

현재 방향은 EnemySpawner에 기본 Prewarm 설정을 두고, BeginPlay()에서 한 번만 Pool을 생성하는 것이다.

UPROPERTY(EditAnywhere, Category = "Spawner|Pool")
TSubclassOf<AEnemyBase> PrewarmEnemyClass;

UPROPERTY(EditAnywhere, Category = "Spawner|Pool")
int32 PrewarmCount = 300;

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

    CachedPlayerCharacter = Cast<APlayerCharacter>(UGameplayStatics::GetPlayerCharacter(this, 0));
    if (!CachedPlayerCharacter)
    {
        UE_LOG(LogTemp, Error, TEXT("Player character not found"));
    }

    if (!PrewarmEnemyClass || PrewarmCount <= 0)
    {
        return;
    }

    UPoolSubsystem* PoolSubsystem = GetWorld()->GetSubsystem<UPoolSubsystem>();
    if (!PoolSubsystem)
    {
        return;
    }

    PoolSubsystem->PrewarmPool(PrewarmEnemyClass, PrewarmCount);
}

주의할 점은 PrewarmEnemyClass와 EnemyData->EnemyClass가 반드시 같아야 한다는 것이다.

예를 들어 Prewarm은 C++ AEnemyBase로 하고, 실제 스폰은 BP_EnemyBase_C로 하면 서로 다른 풀로 취급된다.

따라서 에디터에서 EnemySpawner의 PrewarmEnemyClass에는 실제 EnemyDataAsset들이 사용하는 BP_EnemyBase_C를 넣어야 한다.

디버그 로그로 확인한 흐름

테스트 중에는 다음 흐름을 로그로 확인했다.

[Pool] Prewarm BP_EnemyBase_C / Available: 300
[Pool] Get BP_EnemyBase_C / Available: 299
SpawnedEnemiesList Count After Spawn: 1
[Pool] Get BP_EnemyBase_C / Available: 298
SpawnedEnemiesList Count After Spawn: 2

Available이 줄어든다는 것은 새로 Spawn하는 것이 아니라, 미리 생성해둔 Pool에서 꺼내고 있다는 뜻이다.

Enemy가 죽으면 다음 흐름을 기대한다.

Enemy Returned To Pool: BP_EnemyBase_C_12
Cleanup SpawnedEnemiesList: 10 -> 9

이렇게 나오면 Enemy가 Destroy되지 않고 Pool로 돌아가며, SpawnedEnemiesList에서도 제거되고 있다는 뜻이다.

현재 구조의 주의점

현재 GetActorFromPool() 로그의 Active 값은 실제 Active Enemy 수가 아니다.

IdlePools.Num()

은 활성 Actor 수가 아니라 Pool에 등록된 ActorClass 종류 개수에 가깝다.

따라서 정확한 사용량을 보려면 나중에 다음과 같은 값이 필요하다.

TMap<TSubclassOf<AActor>, int32> TotalCreatedCounts;

그 후 다음처럼 계산할 수 있다.

Active = TotalCreated - Available;

또한 현재 PrewarmCount는 최대 제한이 아니다.

PrewarmCount = 300이어도 301번째 Enemy가 필요하면 새로 Spawn된다. 그리고 그 Enemy가 죽으면 Pool에 들어가므로 Pool 크기는 301까지 늘어날 수 있다.

즉 현재 구조는 고정 크기 풀이 아니라 동적 확장 풀이다.

정리

이번 변경으로 Enemy 스폰 구조는 단순 생성/파괴 방식에서 재사용 가능한 Pooling 구조로 바뀌었다.

핵심은 단순히 Destroy()를 없애는 것이 아니었다.

풀링 구조에서는 Actor가 살아 있어도 게임상으로는 죽은 Enemy일 수 있다. 따라서 게임 로직이 이 상태를 이해할 수 있어야 한다.

이를 위해 다음 요소를 추가했다.

• UPoolSubsystem
• IPoolable
• UPoolableComponent
• EnemyBase의 Pool 반환 처리
• EnemySpawner의 Pool 기반 스폰 처리
• SpawnedEnemiesList의 idle Enemy 정리

결과적으로 Enemy는 죽어도 Actor가 파괴되지 않고 Pool로 돌아가며, 다음 스폰 때 재사용된다.

또한 PoolableComponent의 idle 상태를 기준으로 SpawnedEnemiesList를 정리해, 죽은 Enemy가 살아있는 Enemy처럼 카운트되는 문제도 막을 수 있게 됐다.

다음 개선 방향

아직 개선할 부분도 남아 있다.

• 개발용 로그 정리
• Active 수 계산 개선
• PrewarmPool()을 부족분만 생성하는 방식으로 변경
• Pool 최대 크기 제한 검토
• SpawnedEnemiesList 타입을 AActor에서 AEnemyBase 중심으로 변경
• ReturnToPool 시 Spawner에 이벤트로 알리는 방식 검토

현재 단계에서는 Enemy Pooling의 핵심 흐름이 잡혔다.
다음 단계에서는 디버그용 코드를 정리하고, Pool 사용량을 더 정확하게 추적하는 방향으로 개선하면 좋을 것 같다.

📅 2026-05-13

무한성이라고 불리던 스테이지를 일찍 탈출한 6명이서 사이드 프로젝트를 진행하기로 했다. 순전히 기능 공부를 위함이고 출시계획같은건 당연하게도 없다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

Enemy Spawner Pooling

풀링이란?

기존 언리얼에서 스포너로 액터 생성 시 아래와 같은 형태를 취한다.

- 필요할 때 Spawn
- 사용 끝나면 Destroy
- 필요하면 다시 Spawn
- 사용 끝나면 다시 Destroy

풀링 적용 시

- 게임 시작 시 미리 Spawn
- 비활성화 상태로 보관
- 필요할 때 활성화
- 사용 끝나면 Destroy하지 않고 다시 비활성화
- 다음에 재사용

풀링(Object Pooling)은 오브젝트를 필요할 때마다 계속 생성 → 사용 → 제거하지 않고, 미리 여러 개 만들어 둔 뒤 재사용하는 기법

왜 쓰는가?

언리얼에서 SpawnActor는 단순히 메모리에 객체 생성하는 수준이 아니고 생각보다 복잡하다.

- Actor 생성
- Component 생성
- Transform 설정
- Collision 등록
- BeginPlay 호출
- Tick 등록
- Replication 준비
- Physics 등록
- Rendering 등록

반대의 경우로 Destory()시에도 바로 사라지는게 아니라 엔진 라이프 사이클에 따라서 제거 예약, 참조 정리, GC 처리 등이 얽힌다.

그래서 아래와 같은 상황에서는 풀링을 사용하는게 유리하다.

- 총알
- 투사체
- 피격 이펙트
- 폭발 이펙트
- 데미지 숫자UI
- 드랍 아이템
- 몬스터 스폰/웨이브
- 특정 잔해 조각들
- 발자국, 탄피, 흔적들

조심해야하는 포인트

풀링에서 가장 많이 터지는 버그는 이전 상태가 남아있는 것이다. 반환시 반드시 초기화 해야하는 것들이 있는데 총알로 예를 들 경우

- Location
- Rotation
- Velocity
- Direction
- LifeCycle
- Coliision state
- Tick
- Visibility
- Particle State
- Sound State
- Damage Owner
- Instigator
- Target
- Overlap List
- Timer
- Delegate Binding

위 항목들을 반드시 초기화 해줘야한다. 언리얼에서 특히 버그가 많이 발생하는 부분은 Timer, Delegate, Collision, Overlap, Particle이다.

멀티플레이에서 풀링 시 HOST 기준

실제 구현 고민

프로젝트 같이하는 조에서 라이브러리를 추천받아서 사용해볼까 했으나 직접 구현을 한번 해보는게 좋을 것 같아서 구현하게됐다.

C++로 구현구상

대충 요런 느낌인데 Unreal에서는 vector말고 TArray 써야되니까 Unreal버전으로도 작성해보자.

// poolingManager
std::vector<std::unique_ptr<AEnemyBase>> DeactiveEnemyPool;
std::vector<std::unique_ptr<AEnemyBase>> IdleEnemyPool;


int32 EnemyPoolSize = 200;

for(int32 i = 0; i < EnemyPoolSize; i++)
{
    // EnemyClass는 실제 BP클래스
    AEnemyBase* Enemy = GetWorld()->SpawnActor<AEnemyBase>(EnemyClass);
    DeactiveEnemyPool.Add(Enemy);
}


// Enemy Spawner
void AEnemySpawner::SpawnEnemy() 
{
    AEnemyBase* Enemy = nullptr;

    // 기존 SpawnActor 대신 Pool 
    Enemy->ActiveFromPool(EnemyData);
}

void AEnemySpawner::ReturnEnemyToPool(AEnemyBase* Enemy)
{
    // 기존 Destory() 대신 Pool
    SpawnedEnemyList.Remove(Enemy);
    Enemy->DeactiveToPool();
    IdleEnemyPool.Add(Enemy);
}

📅 2026-05-12

무한성이라고 불리던 스테이지를 일찍 탈출한 6명이서 사이드 프로젝트를 진행하기로 했다. 순전히 기능 공부를 위함이고 출시계획같은건 당연하게도 없다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

Data Asset 기반으로 리팩토링

EnemySpawner.cpp

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


#include "Spawner/EnemySpawner.h"

#include "NavigationSystem.h"
#include "Entity/Character/PlayerCharacter.h"
#include "Components/CapsuleComponent.h"
#include "DataAsset/EnemyDataAsset.h"
#include "DataAsset/WaveDataAsset.h"
#include "Entity/Enemy/EnemyBase.h"
#include "Kismet/GameplayStatics.h"

// Sets default values
AEnemySpawner::AEnemySpawner()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void AEnemySpawner::BeginPlay()
{
    Super::BeginPlay();

    CachedPlayerCharacter = Cast<APlayerCharacter>(UGameplayStatics::GetPlayerCharacter(this, 0));
    if (!CachedPlayerCharacter)
    {
        UE_LOG(LogTemp, Error, TEXT("Player character not found"));
    }
}

void AEnemySpawner::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    if (!bIsSpawning || !CurrentWaveData)
    {
        return;
    }

    WaveElapsedTime += DeltaTime;
    TimeSinceLastSpawn += DeltaTime;

    const FSpawnSegment* CurrentSegment = FindCurrentSpawnSegment();

    if (!CurrentSegment)
    {
        return;
    }

    if (TimeSinceLastSpawn >= CurrentSegment->SpawnInterval)
    {
        TimeSinceLastSpawn = 0.f;

        if (const FEnemySpawnGroup* SpawnGroup = SelectEnemySpawnGroup(*CurrentSegment))
        {
            SpawnEnemyFromGroup(*SpawnGroup);
        }
    }

    if (!bBossSpawned && CurrentWaveData->BossEnemyDataAsset && WaveElapsedTime >= CurrentWaveData->BossSpawnTime)
    {
        bBossSpawned = true;
        SpawnBoss();
    }
}

void AEnemySpawner::SetWaveData(UWaveDataAsset* NewWaveData)
{
    CurrentWaveData = NewWaveData;
    WaveElapsedTime = 0.f;
    TimeSinceLastSpawn = 0.f;
    bBossSpawned = false;

    if (CurrentWaveData)
    {
        UE_LOG(LogTemp, Warning, TEXT("EnemySpawner: Wave data set. WaveIndex=%d"), CurrentWaveData->WaveIndex);
    }
}

FVector AEnemySpawner::GetPlayerLocation() const
{
    if (!CachedPlayerCharacter)
    {
        return FVector::ZeroVector;
    }

    return CachedPlayerCharacter->GetActorLocation();
}

void AEnemySpawner::StartSpawning()
{
    bIsSpawning = true;

    TimeSinceLastSpawn = 0.f;
}

void AEnemySpawner::StopSpawning()
{
    bIsSpawning = false;
}

const FSpawnSegment* AEnemySpawner::FindCurrentSpawnSegment() const
{
    if (!CurrentWaveData)
    {
        return nullptr;
    }

    for (const FSpawnSegment& Segment : CurrentWaveData->SpawnSegments)
    {
        if (WaveElapsedTime >= Segment.StartTime && WaveElapsedTime < Segment.EndTime)
        {
            return &Segment;
        }
    }

    return nullptr;
}

const FEnemySpawnGroup* AEnemySpawner::SelectEnemySpawnGroup(const FSpawnSegment& Segment) const
{
    float totalWeight = 0.f;

    for (const FEnemySpawnGroup& Group : Segment.EnemyGroups)
    {
        if (Group.EnemyData && Group.SpawnWeight > 0.f)
        {
            totalWeight += Group.SpawnWeight;
        }
    }

    if (totalWeight <= 0.f)
    {
        return nullptr;
    }

    float randValue = FMath::FRandRange(0.f, totalWeight);

    for (const FEnemySpawnGroup& Group : Segment.EnemyGroups)
    {
        if (!Group.EnemyData || Group.SpawnWeight <= 0.f)
        {
            continue;
        }

        randValue -= Group.SpawnWeight;
        if (randValue <= 0.f)
        {
            return &Group;
        }
    }

    return nullptr;
}

void AEnemySpawner::SpawnEnemyFromGroup(const FEnemySpawnGroup& SpawnGroup)
{
    SpawnEnemyFromData(
        SpawnGroup.EnemyData,
        SpawnGroup.CountPerSpawn
        );
}

void AEnemySpawner::SpawnEnemyFromData(class UEnemyDataAsset* EnemyData, int32 Count)
{
    if (!EnemyData || !EnemyData->EnemyClass)
    {
        UE_LOG(LogTemp, Warning, TEXT("EnemySpawner: Invalid EnemyData"));
        return;
    }

    CleanupInvalidEnemies();

    for (int32 i=0; i < Count; ++i)
    {
        FVector SpawnLocation;
        if (!FindSpawnLocation(SpawnLocation))
        {
            UE_LOG(LogTemp, Warning, TEXT("EnemySpawner: FindSpawnLocation failed"));
            continue;
        }

        AEnemyBase* DefaultEnemy = EnemyData->EnemyClass->GetDefaultObject<AEnemyBase>();
        if (DefaultEnemy && DefaultEnemy->GetCapsuleComponent())
        {
            SpawnLocation.Z = DefaultEnemy->GetCapsuleComponent()->GetScaledCapsuleHalfHeight();
        }

        FActorSpawnParameters SpawnParams;

        SpawnParams.Owner = this;
        SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding;

        AEnemyBase* SpawnedEnemy = GetWorld()->SpawnActor<AEnemyBase>(
            EnemyData->EnemyClass,
            SpawnLocation,
            FRotator::ZeroRotator,
            SpawnParams
        );

        if (SpawnedEnemy)
        {
            SpawnedEnemy->InitializeFromData(EnemyData);
            SpawnedEnemiesList.Add(SpawnedEnemy);
        }
    }
}

void AEnemySpawner::SpawnBoss()
{
    if (!CurrentWaveData || !CurrentWaveData->BossEnemyDataAsset)
    {
        return;
    }

    SpawnEnemyFromData(CurrentWaveData->BossEnemyDataAsset, 1);
}


bool AEnemySpawner::FindSpawnLocation(FVector& SpawnLocation) const
{
    const float angle = FMath::FRandRange(0.f, 2.f * PI);

    FVector direction(
        FMath::Cos(angle),
        FMath::Sin(angle),
        0.f
    );

    const float distance = FMath::FRandRange(MinSpawnDistance, MaxSpawnDistance);

    const FVector candidateLocation = GetPlayerLocation() + direction * distance;


    UNavigationSystemV1* NavSystem = UNavigationSystemV1::GetCurrent(GetWorld());
    if (!NavSystem)
    {
        return false;
    }

    FNavLocation navLocation;

    // candidateLocation이 정확히 NavMesh 위가 아닐 수도 있음
    // xyz 5미터 탐색지역 생성
    const FVector QueryExtent(500.f, 500.f, 500.f);

    // candidateLocation 주변 QueryExtent 내에서 Nav Mesh 탐색
    // ProjectPointToNavigation = 입력위치를 navigation data위로 투영 > FNavLocation return
    const bool bProjected = NavSystem->ProjectPointToNavigation(
        candidateLocation,
        navLocation,
        QueryExtent
    );

    if (!bProjected)
    {
        return false;
    }

    UE_LOG(LogTemp, Warning, TEXT("Spawned"));

    SpawnLocation = navLocation.Location;
    return true;
}

void AEnemySpawner::CleanupInvalidEnemies()
{
    SpawnedEnemiesList.RemoveAll([](const TObjectPtr<AActor>& Enemy)
    {
        return !IsValid(Enemy);
    });
}

📅 2026-05-11

무한성이라고 불리던 스테이지를 일찍 탈출한 6명이서 사이드 프로젝트를 진행하기로 했다. 순전히 기능 공부를 위함이고 출시계획같은건 당연하게도 없다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

EnemySpawner

EnemySpawn() 시 에러발생

LogTemp: Warning: Spawned
LogSpawn: Warning: SpawnActor failed because of collision at the spawn location [X=2194.936 Y=-2181.662 Z=10.000] for [BP_EnemyBase_C]
LogTemp: Warning: Spawned
LogSpawn: Warning: SpawnActor failed because of collision at the spawn location [X=-354.411 Y=2057.717 Z=10.000] for [BP_EnemyBase_C]
LogTemp: Warning: Spawned
LogSpawn: Warning: SpawnActor failed because of collision at the spawn location [X=-2411.997 Y=-519.608 Z=10.000] for [BP_EnemyBase_C]
LogTemp: Warning: Spawned
LogSpawn: Warning: SpawnActor failed because of collision at the spawn location [X=1004.887 Y=-2139.610 Z=10.000] for [BP_EnemyBase_C]
LogTemp: Warning: Spawned
LogSpawn: Warning: SpawnActor failed because of collision at the spawn location [X=445.794 Y=-2630.596 Z=10.000] for [BP_EnemyBase_C]

에러를 확인해보면 해당 스폰 지점 콜리전 충돌로 스폰에 실패했다고 한다.

아마도 스폰되는 BP_EnemyBase의 캡슐컴포넌트의 height값이 88인데 10에 스폰하려고 하면 안되지않을까.. 싶었다.

    // 스폰 위치 선언
    FVector SpawnLocation;

    // spawn location 체크결과 false일 경우 return
    if (!FindSpawnLocation(SpawnLocation))
    {
        UE_LOG(LogTemp, Warning, TEXT("Enemy Spawner: Failed to find spawn location"));
        return;
    }

    SpawnLocation.Z = 100;

그래서 위와같이 spawnlocation.z 를 100으로 설정해주니까

스폰이 잘 된다! 그런데 문제가 하나 더 있다.

위에서 말했듯 BP_EnemyBase의 캡슐컴포넌트의 height가 88인데 100으로 설정해 주었더니

이놈들이 공중부양해서 다닌다.. 그래서 코드를 수정해서 BP_EnemyClass의 캡슐 컴포넌트의 halfheight값을 z에 넣어주도록 하겠다.

    ACharacter* DefaultEnemy = EnemyClass->GetDefaultObject<ACharacter>();
    if (!DefaultEnemy || !DefaultEnemy->GetCapsuleComponent())
    {
        return;
    }
    const float EnemyCapsuleHeight = DefaultEnemy->GetCapsuleComponent()->GetScaledCapsuleHalfHeight();
    SpawnLocation.Z = EnemyCapsuleHeight;

📅 2026-05-08

무한성이라고 불리던 스테이지를 일찍 탈출한 6명이서 사이드 프로젝트를 진행하기로 했다. 순전히 기능 공부를 위함이고 출시계획같은건 당연하게도 없다.

프로젝트 진행기간 : 26.05.11 ~ 26.05.21

주제는 3D 뱀파이어 서바이벌이다. 개발 진행상황은 레포지토리 참조

MVP 스팩을 크게 6가지로 나눴다. 스킬 / 캐릭터 / 적 / 시스템(웨이브, 스포너) / 아이템 / UI 나는 그 중 시스템(웨이브, 스포너)를 담당하게 됐다.

EnemySpawner

마침 해당 사이드 프로젝트를 진행하기 전 EnemySpawner를 만들어봤었다. 해당 코드 첨부

EnemySpawner.h

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

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "EnemySpawner.generated.h"

class ACharacter;

UCLASS()
class METAL3D_API AEnemySpawner : public AActor
{
    GENERATED_BODY()

public:
    // Sets default values for this actor's properties
    AEnemySpawner();

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

public:
    UFUNCTION(BlueprintCallable, Category="Spawner")
    void StartSpawning();

    UFUNCTION(BlueprintCallable, Category="Spawner")
    void StopSpawning();

private:
    UPROPERTY(EditAnywhere, Category="Spawner")
    TSubclassOf<ACharacter> EnemyClass;

    UPROPERTY(EditAnywhere, Category="Spawner")
    float SpawnRadius = 1200.f;

    UPROPERTY(EditAnywhere, Category="Spawner")
    float SpawnInterval = 3.f;

    UPROPERTY(EditAnywhere, Category="Spawner")
    int32 MaxEnemyCount = 100;

    UPROPERTY(EditAnywhere, Category="Spawner")
    bool bAutoStart = true;

    UPROPERTY()
    TArray<TObjectPtr<AActor>> SpawnedEnemies;

    FTimerHandle SpawnTimerHandler;

    void SpawnEnemy();

    bool FindSpawnLocation(FVector& OutLocation) const;

    void CleanupInvalidEnemies();
};

EnemySpawner.cpp

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


#include "Spawner/EnemySpawner.h"

#include "NavigationSystem.h"
#include "GameFramework/Character.h"
#include "TimerManager.h"
#include "Components/CapsuleComponent.h"
#include "Engine/World.h"

// Sets default values
AEnemySpawner::AEnemySpawner()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void AEnemySpawner::BeginPlay()
{
    Super::BeginPlay();

    if (bAutoStart)
    {
        StartSpawning();
    }
}

void AEnemySpawner::StartSpawning()
{
    if (!GetWorld())
    {
        return;
    }

    GetWorld()->GetTimerManager().SetTimer(
        SpawnTimerHandler,
        this,
        &AEnemySpawner::SpawnEnemy,
        SpawnInterval,
        true,
        0.f
    );
}

void AEnemySpawner::StopSpawning()
{
    if (!GetWorld())
    {
        return;
    }

    GetWorld()->GetTimerManager().ClearTimer(SpawnTimerHandler);
}

void AEnemySpawner::SpawnEnemy()
{
    if (!EnemyClass)
    {
        UE_LOG(LogTemp, Warning, TEXT("Enemy Spawner: EnemyClass not set"));
        return;
    }

    CleanupInvalidEnemies();
    if (SpawnedEnemies.Num() >= MaxEnemyCount)
    {
        return;
    }

    FVector SpawnLocation;
    if (!FindSpawnLocation(SpawnLocation))
    {
        UE_LOG(LogTemp, Warning, TEXT("Enemy Spawner: Failed to find spawn location"));
        return;
    }

    ACharacter* DefaultEnemy = EnemyClass->GetDefaultObject<ACharacter>();
    if (!DefaultEnemy || !DefaultEnemy->GetCapsuleComponent())
    {
        return;
    }

    const float CapsuleHalfHeight = DefaultEnemy->GetCapsuleComponent()->GetScaledCapsuleHalfHeight();
    SpawnLocation.Z += CapsuleHalfHeight;

    const FRotator SpawnRotation = FRotator::ZeroRotator;

    FActorSpawnParameters SpawnParams;

    SpawnParams.Owner = this;
    SpawnParams.SpawnCollisionHandlingOverride =
        ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding;

    ACharacter* SpawnedEnemy = GetWorld()->SpawnActor<ACharacter>(
        EnemyClass,
        SpawnLocation,
        SpawnRotation,
        SpawnParams
    );

    if (SpawnedEnemy)
    {
        SpawnedEnemies.Add(SpawnedEnemy);
    }
}

bool AEnemySpawner::FindSpawnLocation(FVector& OutLocation) const
{
    UNavigationSystemV1* NavSystem = UNavigationSystemV1::GetCurrent(GetWorld());

    if (!NavSystem)
    {
        return false;
    }

    FNavLocation NavLocation;

    const bool bFound = NavSystem->GetRandomReachablePointInRadius(
        GetActorLocation(),
        SpawnRadius,
        NavLocation
    );

    if (!bFound)
    {
        return false;
    }

    OutLocation = NavLocation.Location;
    return true;
}

void AEnemySpawner::CleanupInvalidEnemies()
{
    SpawnedEnemies.RemoveAll([](const TObjectPtr<AActor>& Enemy)
    {
        return !IsValid(Enemy);
    });
}

해당 코드를 복붙 후 수정.. 하고싶지만 우선은 Unreal c++에 익숙해지는게 먼저기 때문에 다시 손으로 따라쳐볼 예정이다. 거기에 달라지는 점들이 몇가지 있어서 추가 수정을 붙일 예정이다.

📅 2026-05-07

C++ 캐릭터 생성

PlayerCharacter.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "InputActionValue.h"

#include "PlayerCharacter.generated.h"

class UInputMappingContext;
class UInputAction;
class USceneComponent;

UCLASS()
class METAL3D_API APlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    // Sets default values for this character's properties
    APlayerCharacter();

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

    // 인풋 컴포넌트 오버라이드
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")
    TObjectPtr<UInputMappingContext> DefaultMappingContext;

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")
    TObjectPtr<UInputAction> MoveAction;

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")
    TObjectPtr<UInputAction> LookAction;

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")
    TObjectPtr<UInputAction> FireAction;

    virtual void NotifyControllerChanged() override;


    // Projectile
    UPROPERTY(EditDefaultsOnly, Category="Combat")
    TSubclassOf<class AProjectile> ProjectileClass;

    USceneComponent* FindMuzzlePoint() const;
    UPROPERTY(EditDefaultsOnly, Category="Combat")
    FName MuzzlePointComponentName = TEXT("MuzzlePoint");

    UPROPERTY(EditDefaultsOnly, Category="Combat")
    float AimTraceDistance = 10000.f;

    void Fire();

public:
    // Called every frame
    virtual void Tick(float DeltaTime) override;

private:
    void Move(const FInputActionValue& Value);
    void Look(const FInputActionValue& Value);
};

PlayerCharacter.cpp

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


#include "Player/PlayerCharacter.h"

#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
#include "Projectile/Projectile.h"
#include "GameFramework/PlayerController.h"
#include "Camera/CameraComponent.h"
#include "Kismet/GameplayStatics.h"
#include "GameFramework/PlayerController.h"
#include "DrawDebugHelpers.h"

// Sets default values
APlayerCharacter::APlayerCharacter()
{
    // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void APlayerCharacter::BeginPlay()
{
    Super::BeginPlay();
}

// Called every frame
void APlayerCharacter::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

// Called to bind functionality to input
void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);

    if (!EnhancedInputComponent)
    {
        return;
    }

    if (MoveAction)
    {
        EnhancedInputComponent->BindAction(
            MoveAction,
            ETriggerEvent::Triggered,
            this,
            &APlayerCharacter::Move
        );
    }

    if (LookAction)
    {
        EnhancedInputComponent->BindAction(
            LookAction,
            ETriggerEvent::Triggered,
            this,
            &APlayerCharacter::Look
        );
    }

    if (FireAction)
    {
        EnhancedInputComponent->BindAction(
            FireAction,
            ETriggerEvent::Triggered,
            this,
            &APlayerCharacter::Fire
        );
    }
}

void APlayerCharacter::NotifyControllerChanged()
{
    Super::NotifyControllerChanged();

    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if (!PlayerController)
    {
        return;
    }

    ULocalPlayer* LocalPlayer = PlayerController->GetLocalPlayer();
    if (!LocalPlayer)
    {
        return;
    }

    UEnhancedInputLocalPlayerSubsystem* InputSubsystem = LocalPlayer->GetSubsystem<
        UEnhancedInputLocalPlayerSubsystem>();
    if (InputSubsystem && DefaultMappingContext)
    {
        InputSubsystem->AddMappingContext(DefaultMappingContext, 0);
    }
}


void APlayerCharacter::Move(const FInputActionValue& Value)
{
    const FVector2D MovementVector = Value.Get<FVector2D>();

    if (Controller == nullptr)
    {
        return;
    }

    const FRotator ControlRotation = Controller->GetControlRotation();
    const FRotator YawRotation(0.0f, ControlRotation.Yaw, 0.0f);

    const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

    AddMovementInput(ForwardDirection, MovementVector.Y);
    AddMovementInput(RightDirection, MovementVector.X);
}

void APlayerCharacter::Look(const FInputActionValue& Value)
{
    const FVector2D LookAxis = Value.Get<FVector2D>();

    AddControllerYawInput(LookAxis.X);
    AddControllerPitchInput(-LookAxis.Y);
}

USceneComponent* APlayerCharacter::FindMuzzlePoint() const
{
    TArray<USceneComponent*> SceneComponents;

    GetComponents<USceneComponent>(SceneComponents);

    for (USceneComponent* Component : SceneComponents)
    {
        if (IsValid(Component) && Component->GetName() == MuzzlePointComponentName.ToString())
        {
            return Component;
        }
    }

    return nullptr;
}


void APlayerCharacter::Fire()
{
    if (!ProjectileClass)
    {
        return;
    }

    APlayerController* PC = Cast<APlayerController>(GetController());
    if (!PC)
    {
        return;
    }

    int32 ViewportX = 0;
    int32 ViewportY = 0;

    PC->GetViewportSize(ViewportX, ViewportY);

    const float ScreenCenterX = ViewportX * 0.5f;
    const float ScreenCenterY = ViewportY * 0.5f;

    FVector WorldLocation;
    FVector WorldDirection;

    const bool bDeprojected = PC->DeprojectScreenPositionToWorld(
        ScreenCenterX,
        ScreenCenterY,
        WorldLocation,
        WorldDirection
    );

    if (!bDeprojected)
    {
        return;
    }

    const FVector TraceStart = WorldLocation;
    const FVector TraceEnd = TraceStart + WorldDirection * AimTraceDistance;

    FHitResult CameraHit;

    FCollisionQueryParams QueryParams;
    QueryParams.AddIgnoredActor(this);

    GetWorld()->LineTraceSingleByChannel(
        CameraHit,
        TraceStart,
        TraceEnd,
        ECC_Visibility,
        QueryParams
    );

    const FVector AimTarget = CameraHit.bBlockingHit ? CameraHit.ImpactPoint : TraceEnd;

    const USceneComponent* MuzzlePoint = FindMuzzlePoint();
    const FVector MuzzleLocation = MuzzlePoint->GetComponentLocation();

    const FVector FireDirection = (AimTarget - MuzzleLocation).GetSafeNormal();

    const FRotator SpawnRotation = FireDirection.Rotation();

    DrawDebugLine(
        GetWorld(),
        TraceStart,
        TraceEnd,
        FColor::Green,
        false,
        2.f,
        0,
        1.f
    );

    DrawDebugLine(
        GetWorld(),
        MuzzleLocation,
        MuzzleLocation + FireDirection * 3000.f,
        FColor::Red,
        false,
        2.f,
        0,
        2.f
    );

    FActorSpawnParameters SpawnParams;
    SpawnParams.Owner = this;
    SpawnParams.Instigator = this;
    SpawnParams.SpawnCollisionHandlingOverride =
        ESpawnActorCollisionHandlingMethod::AlwaysSpawn;

    GetWorld()->SpawnActor<AProjectile>(
        ProjectileClass,
        MuzzleLocation,
        SpawnRotation,
        SpawnParams
    );
}

📅 2026-05-06

UE-Handbook

기존 에픽게임즈 언리얼 공식문서가 사실 초보가 보기에는 너무 어렵게 되어있다. 그래서 Docusaurus이용해서 handbook을 만들어봤다. 아이디어는 예전에 TS handbook이 도움이 많이됐던게 기억나서 만들어봤다. 유지보수를 계속 할지는 모르겠지만 혹시 필요한사람들이 많이들 봤으면 좋겠다.

C++ 사용 IMC, IA 등록

언리얼에서 pawn, character가 사용자의 입력대로 이동하려면 Input Mapping Context와 Input Action을 등록해주어야한다.

이전에는 블루프린트로 가볍게 했지만 C++에서는 어떻게 하는지 알아보자.

IMC, IA 생성

일단 IMC, IA생성은 블루프린트와 동일하다.

IMC

IA

C++ PlayerCharacter 클래스 생성

Character 클래스를 부모로 만든 PlayerCharacter 클래스를 생성해준다.

PlayerCharacter.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "APlayerCharacter.generated.h"

UCLASS()
class METAL3D_API APlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    // Sets default values for this character's properties
    APlayerCharacter();

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

public:    
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    // Called to bind functionality to input
    virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

};

PlayerCharacter.cpp

#include "Player/PlayerCharacter.h"

// Sets default values
APlayerCharacter::APlayerCharacter()
{
     // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;

}

// Called when the game starts or when spawned
void APlayerCharacter::BeginPlay()
{
    Super::BeginPlay();

}

// Called every frame
void APlayerCharacter::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

// Called to bind functionality to input
void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

}

생성 해준 뒤에는 미리 만들어놓은 IMC와 IA를 연결하는 작업을 진행해준다.

PlayerCharacter.h 수정

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "InputActionValue.h"

#include "PlayerCharacter.generated.h"

class UInputMappingContext;
class UInputAction;

UCLASS()
class METAL3D_API APlayerCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    // Sets default values for this character's properties
    APlayerCharacter();

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

    // 인풋 컴포넌트 오버라이드
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")
    TObjectPtr<UInputMappingContext> DefaultMappingContext;

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")
    TObjectPtr<UInputAction> MoveAction;

    virtual void NotifyControllerChanged() override;

public:
    // Called every frame
    virtual void Tick(float DeltaTime) override;

private:
    void Move(const FInputActionValue& Value);
};

해설 및 수정사항

뭐가 많이 추가됐는데 한줄씩 보겠다.

헤더 include

include "InputActionValue.h"

이 헤더는 아래서 정의한 void Move(const FInputActionValue& Value)에서 FInputActionValue타입을 헤더의 상수 시그니처에서 사용 중이기 때문에 필요하다.

include "PlayerCharacter.generated.h"

해당 헤더는는 언리얼 리플렉션 코드 생성용 헤더이다. *.generated.h는 반드시 해당 헤더의 include중 마지막에 와야한다.

전방선언

class UInputMappingContext;
class UInputAction;

protected:에서 선언된

UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")
TObjectPtr<UInputMappingContext> DefaultMappingContext;

UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")
TObjectPtr<UInputAction> MoveAction;

에서 포인터로써만 들고있기 때문에 헤더에서는 전체 include가 아닌 전방선언만 해도 오케이다.

UCLASS()

언리얼 리플렉션 시스템에 해당 클래스를 등록한다.

이게 있어야 BP생성시 해당 클래스를 부모로 선택 가능하고 UPROPERTY,UFUNCTION 같은 시스템도 작동한다.

METAL3D_API

프로젝트 모듈 export/import 매크로 프로젝트명이 Metal3D라서 자동으로 붙은 것이다.

APlayerCharacter : public ACharacter

ACharacter를 상속받은 PlayerCharacter 클래스

AActor
자식 > APawn
의 자식 > ACharacter
의 자식 > APlayerCharacter

class 이름이 PlayerCharacter인데 왜 APlayerCharacter일까?

GENERATED_BODY()

언리얼이 생성한 리플렉션 코드를 클래스 안에 삽입하는 매크로 UCLASS() 에는 필수로 들어간다.

APlayerCharacter()

APlayerCharacter();

생성자

Beginplay

virtual void BeginPlay() override;

블프에서 많이 보던 BeginPlay 노드가 이 부분이다.

SetupPlayerInputComponent

virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

Pawn/Character가 Possess되어 입력 컴포넌트가 준비될 때 호출

블프와는 다르게 여기서 IMC, IA를 연결한다.

UPROPERTY(...)

UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Input")

UPROPERTY 일반 C++변수를 리플렉션 시스템에 등록하는 매크로 등록된 변수는 언리얼 에디터에서 노출되며 블루프린트 접근, 직렬화, GC 추적같은 언언리얼 기능의 대상이 된다.

EditDefaultsOnly 인스턴스마다 수정하는 값이 아닌 클래스 기본값, BP defaults에서만 수정 가능하게 한다.

BlueprintReadOnly 블루프린트에서 해당 값을 읽을 수는 있지만 수정할 수는 없다.

Category="Input" 언리얼 에디터 > Detail 패널 내에서 Input 카테고리 아래에서 보여준다.

TObjectPtr<UInputMappingContext>

TObjectPtr<UInputMappingContext> DefaultMappingContext;

UinputMappingContext 타입의 UObject를 가리키는 포인터. IMC_PlayerCharacter같은 IMC 에셋을 참조한다.

NotifyControllerChanged()

virtual void NotifyControllerChanged() override;

pawn, character를 소유하거나 조종하는 Controller가 변경되었음을 알리는 함수

플레이어가 조종하면 APlayerController AI가 조종하면 AAIController가 붙는다.

해당 함수는 Controller가 변경되는 시점에 호출되는데 대표적으로

• PlayerController가 Character에 Possess됐을 때
• Controller가 바뀌었을 때
• Possess, UnPossess 흐름에서 Controller 상태가 달라졌을 때

블프와 달리 IMC를 해당 함수에서 붙이게 되는데 이유가 BeginPlay()시점에 아직 Controller나 LocalPlayer가 준비되지 않았을 수 있기 때문이다.

Move()

이동 입력을 처리하는 사용자 정의 함수

PlayerCharacter.cpp 수정

#include "Player/PlayerCharacter.h"

#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"

// Sets default values
APlayerCharacter::APlayerCharacter()
{
    // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void APlayerCharacter::BeginPlay()
{
    Super::BeginPlay();


}

// Called every frame
void APlayerCharacter::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

// Called to bind functionality to input
void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);

    if (!EnhancedInputComponent)
    {
        return;
    }

    if (MoveAction)
    {
        EnhancedInputComponent->BindAction(
            MoveAction,
            ETriggerEvent::Triggered,
            this,
            &APlayerCharacter::Move
        );
    }
}

void APlayerCharacter::NotifyControllerChanged()
{
    Super::NotifyControllerChanged();

    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if (!PlayerController)
    {
        return;
    }

    ULocalPlayer* LocalPlayer = PlayerController->GetLocalPlayer();
    if (!LocalPlayer)
    {
        return;
    }

    UEnhancedInputLocalPlayerSubsystem* InputSubsystem = LocalPlayer->GetSubsystem<
        UEnhancedInputLocalPlayerSubsystem>();
    if (InputSubsystem && DefaultMappingContext)
    {
        InputSubsystem->AddMappingContext(DefaultMappingContext, 0);
    }
}


void APlayerCharacter::Move(const FInputActionValue& Value)
{
    const FVector2D MovementVector = Value.Get<FVector2D>();

    if (Controller == nullptr)
    {
        return;
    }

    const FRotator ControlRotation = Controller->GetControlRotation();
    const FRotator YawRotation(0.0f, ControlRotation.Yaw, 0.0f);

    const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
    const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

    AddMovementInput(ForwardDirection, MovementVector.Y);
    AddMovementInput(RightDirection, MovementVector.X);
}

해설 및 수정사항

헤더

#include "EnhancedInputComponent.h"

헤더와는 다르게 EnhancedInputComponent를 포인터로 들고만 있는게 아니라 실제로 멤버 함수를 호출하거나 사용하기 때문에 필요하다.

SetupPlayerInputComponent

void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);

    if (!EnhancedInputComponent)
    {
        return;
    }

    if (MoveAction)
    {
        EnhancedInputComponent->BindAction(
            MoveAction,
            ETriggerEvent::Triggered,
            this,
            &APlayerCharacter::Move
        );
    }
}

pawn, character의 입력 바인딩 구성 함수

Super::SetupPlayerInputComponent(PlayerInputComponent)

Super::는 언리얼 C++에서 부모클래스의 별칭이다. 해당 클래스의 부모클래스에서 해야할 처리를 먼저 수행하겠다는 의미다.

언리얼 오버라이드 함수에서 특별한 이유가 없으면 Super::...()를 호출하는게 기본

Cast<UEnhancedInputComponent>

언리얼의 Cast<>는 c++의 dynamic_cast와 비슷한 목적이다. 다른 점은 Cast<>는 리플렉션 시스템을 기반으로 UObject 타입 변환을 수행한다. 블프에서 많이 보던 Cast to 다

캐스팅을 하는 이유는 함수 인자가 기본 타입이기 때문이다.

// 함수인자 UInputComponent > UEnhancedInputComponent로 캐스팅
UEnhancedInputComponent* EnhancedInputComponent = 
            Cast<UEnhancedInputComponent>(PlayerInputComponent);

실패할 수도 있기 때문에 바로 체크도 해준다.

    if (!EnhancedInputComponent)
    {
        return;
    }

MoveAction 바인딩

if (MoveAction)
    {
        EnhancedInputComponent->BindAction(
            MoveAction,
            ETriggerEvent::Triggered,
            this,
            &APlayerCharacter::Move
        );
    }

헤더에서 UPROPERTY로 등록한 MoveAction이 있다. 언리얼 에디터에서 실제로 IA_Move를 등록해준 IA를 MoveAction에 바인딩해준다.

MoveAction 어떤 Input Action을 감시할지 지정

ETriggerEvent::Triggered Input Action이 어떤 상태일 때 호출할지 정함

this 호출 대상 객체, 현재 PlayerCharacter를 말함

&APlayerCharacter::Move 호출할 멤버함수 포인터

NotifyControllerChanged

void APlayerCharacter::NotifyControllerChanged()
{
    Super::NotifyControllerChanged();

    APlayerController* PlayerController = Cast<APlayerController>(GetController());
    if (!PlayerController)
    {
        return;
    }

    ULocalPlayer* LocalPlayer = PlayerController->GetLocalPlayer();
    if (!LocalPlayer)
    {
        return;
    }

    UEnhancedInputLocalPlayerSubsystem* InputSubsystem = LocalPlayer->GetSubsystem<
        UEnhancedInputLocalPlayerSubsystem>();
    if (InputSubsystem && DefaultMappingContext)
    {
        InputSubsystem->AddMappingContext(DefaultMappingContext, 0);
    }
}

어차피 여러번 할텐데 너무 길어져서 나중에 더 작성해야지

📅 2026-05-04

TextRPG 완성본

깃허브 링크

C++ 학습

SOLID 원칙

inline static과 constexpr

Rider IDE C++ 표준버전 변경법

Rider IDE C++ 표준 버전 변경

inline static 멤버변수 만들려고 하니까 C++ 17 이상에서만 가능하다고 에러가 표시됐다.

Unreal C++ 프로젝트는 자동으로 C++20이상으로 세팅되는데 일단 콘솔 프로젝트는 C++14로 세팅되는 것 같았다.

그래서 프로젝트 자체의 C++ 버전 업 하는 방법을 알아봤다.

프로젝트 > 우클릭 > properties

C++20으로 변경

inline static

class 내무 멤버변수를 static으로 선언할 경우에 초기화가 불가능하다. cpp에서 따로 초기화를 해줘야하는데

C++17부터 inline을 붙임으로써 선언과 동시에 초기화가 가능하다.

class Test
{
    static int a; // 오류X cpp에서 반드시 초기화
    static int a = 10; // 오류 발생

    inline static int a = 10; // 오류X cpp 초기화X

}

constexpr

class Test
{
    static int a;
    constexpr int a = 10;

    static constexpr int a = 10;

}

static

class Test
{
    static int a;
}

int Test::a = 10;

Test::a = 20; // 가능

• 모든 객체가 하나의 x를 공유
• 런타임에 값 변경 가능
• 별도 정의 필요 (C++17 이전 기준)

constexpr

class Test
{
    constexpr int a = 10;
}


Test::a = 20; // 불가능

• 컴파일 타임에 값 확정
• 암묵적으로 const
• 변경 불가
• 함수에도 적용 가능 (constexpr function)

static constexpr

클래스에 속한 컴파일 타임 상수

• static > 클래스 전체에서 공유
• constexpr > 컴파일 타임 상수

1. 컴파일 타임 값

class Test
{
    static constexpr int a = 10;
}

int array[Test::a];

컴파일 타임에 배열의 크기 요구시 static만으로는 불가능(런타임 초기화 해야하기 때문)

2. 헤더에서 안전하게 정의

class Test
{
    static constexpr int a = 10;
}

ODR문제 X 별도의 cpp 필요X

ODR?

One Definition Rule

inline static vs static constexpr

SOLID 원칙

TextRPG를 제작하면서 특정 물체(캐릭터, 적 등)를 Actor라는 최상위 클래스에서 기본적인 요소를 관리했다. Unreal처럼 만들어보고 싶다는 이유에서 였는데 여러 문제가 발생했는데 해당 Actor가

• 공격이 가능한가?
• 피해를 입을 수 있는가?

위 두가지 때문에 캐릭터(폰)라는 한정된 역할만 할 수 있었다. 그때 같은 기수의 Dr. Dragon 'D' Water 님께서 SOLID 원칙을 알려주셨다.

이전에도 FE엔지니어를 하면서 Repository 패턴을 사용할 일이 있었는데 그때 들어본 원칙이기도 하지만 제대로 알아볼 생각은 하지 않았었다. 실제로 3년넘게 실무하면서 class 사용해본 일이 손에 꼽을 정도로 FE에서는 class를 잘 사용하지 않는다.

S(SRP) - Single Responsibility Principle

단일 책임 원칙 클래스는 1개의 이유로만 변경되어야 한다.

class Player {
public:
    void Update();
    void Render();
    void SaveToFile();   // 저장 책임
    void SendNetwork();  // 네트워크 책임
};

// 분리
struct PlayerState {
    int hp;
    Vector3 position;
};

class PlayerSystem {
public:
    void Update(PlayerState&);
};

class SaveSystem {
public:
    void Save(const PlayerState&);
};

O(OCP) - Open/Closed Principle

개방/폐쇄 원칙 확장에는 열려있고 수정에는 닫혀있어야한다.

// 무기 추가할 때마다 값 추가해야함 
int CalcDamage(std::string type) {
    if (type == "sword") return 10;
    if (type == "gun") return 20;
}


// 개선
struct WeaponData
{
    int damage;
}

class Weapon
{
    WeaponData weaponData;

public:
    int ApplyDamage()
    {
        return weaponData.damage;
    }

}

L(LSP) - Liskov Substitution Principle

리스코프 치환 원칙 자식 클래스는 부모 클래스를 완전히 대체 가능해야한다.

class Character
{
public:
    virtual void Attack() = 0;
};

class Pacifist : public Character
{
public:
    // 부모 Character는 Attack 호출 시 함수가 실행되는 것을 기대함
    // Pacifist에서 예외처리로 프로그램을 비정상 종료시키기 때문에 LSP 원칙에 어긋남
    void Attack() override { throw; } 
}



// 개선
class IAttackable
{
public:
    virtual void Attack() = 0;
}

class NPC { }; // 공격 없음
class Box { }; // 공격 없음

class Warrior : public IAttackable
{
    void Attack() override { ... }
}

I(ISP) - Interface Segregation Principle

인터페이스 분리 원칙 클라이언트는 자신이 사용하지 않는 인터페이스에 의존해서는 안된다.

class IUnit
{
public:
    virtual void Move() = 0;
    virtual void Attack() = 0;
    virtual void Fly() = 0; // 거북이 Actor에 Fly???
}


// 개선
class MoveComponent { void Move(); }
class AttackComponent { void Attack(); }
class FlyComponenty { void Fly(); }

class Unit
{
    MoveComponent* move;
    AttackComponent* attack;
    // 해당 Unit은 Fly 기능이 없으므로 객체 생성X
}

D(DIP) - Dependency Inversion Principle

의존성 역전 원칙 고수준 모듈은 저수준 모듈에 의존해서는 안되고 둘 다 추상화에 의존해야한다.

// Game이 더 고수준 모듈
class Game
{
    // 저수준 모듈 Sword에 의존하면 원칙 위배
    Sword sword;
}

// 개선

class Weapon
{
public:
    virtual void Attack() = 0;
}

class Game
{
    std::unique_ptr<Weapon> weapon;

    Game(satd::unique_ptr<Weapon> w) : weapon(std::move(w)) { };

}

총 정리

SRP → “변경 이유 1개” 시스템 단위 분리 OCP → “코드 말고 데이터로 확장” 데이터 기반 확장 LSP → “상속 대신 능력 분리” 상속 최소화 ISP → “인터페이스 → 컴포넌트로” 컴포넌트 DIP → “new 하지 말고 주입해라” DI + smart pointer

📅 2026-04-30

가상함수와 추상클래스

참고: https://baggu4402.tistory.com/15

TRPG 개발 중 캐릭터의 직업클래스와 부모 클래스를 만들면서 사용할 일이 있어서 알아봤다.

C++에서는 java처럼 abstact같은 키워드가 없다.

순수가상함수가 포함되어 있는 클래스는 추상클래스로 취급되고 순수가상함수는 상속받는 자식클래스에서 반드시 구현해야한다.

순수 가상 함수는 부모의 강제 규칙, 오버라이딩은 자식의 실제 구현.

class Job
{
public:
    virtual Stat SetBaseState() const = 0;
    virtual std::string GetJobName() const = 0;
}

class Warrior : public Job
{
    Stat SetBaseState() const override
    {
        ...구현...
    }
    std::string GetJobName() const override
    {
        ...구현...
    }
}

TS interface 생각하면 편함!

사실 class는 뭐 HttpClient 구현체 만들때나 쓰고 일부 백엔드 작업하면서나 써봤지 알고는 있지만 쓸일이 그닥 많지는 않았다.

어렵게 생각하지말고 내 입장에서는 추상클래스 = interface 라고 생각하면 기초수준에서의 이해는 되는 것 같다.

다만 다른점은 C++ 추상클래스는 클래스가 구현을 포함할 수 있고 TS interface는 구현을 위한 명세만을 다룬다는 점이다. 또한 TS interface는 ? 를 사용해 해당 함수가 상속받는 클래스 내부에 존재할수도 존재하지 않을 수도 있는 상태를 만들 수 있는데

C++에는 그런 방법이 없고 SOLID 원칙에서 안티패턴으로 간주하고 리팩토링을 하는 것을 권장하고있다.

에러케이스

#pragma once
#include <functional>
#include <map>
#include <string>

#include "Actor/Stat.h"

enum class JobState { Warrior, Mage };

class Job
{
    std::map<char, std::function<void()>> jobFuncMap;

public:
    virtual std::string Test();
    virtual Stat SetBaseStat() const = 0;
    virtual std::string GetJobName() const = 0;
};

순수가상함수 아니면 되는거 아니었나요?

순수가상함수는 구현할 필요가 없습니다. 왜냐? 자식클래스에서 반드시 구현해야 하기 때문에 추상클래스에서 구현할 필요가 없습니다. 하지만 일반 가상함수는 컴파일러가 어딘가에 구현이 있다고 생각하고 링크를 하다가 구현이 없으면 LNK에러가 발생하게 됩니다.

#pragma once
#include <functional>
#include <map>
#include <string>

#include "Actor/Stat.h"

enum class JobState { Warrior, Mage };

class Job
{
    std::map<char, std::function<void()>> jobFuncMap;

public:
    virtual std::string Test() { return "" } ;
    virtual Stat SetBaseStat() const = 0;
    virtual std::string GetJobName() const = 0;
};

그래서 위와같이 구현을 추가해주면 에러가 사라집니다.

랜덤

던전 이벤트 구현을 위해 C++에서는 랜덤을 어떻게 돌리나 검색을 해봤다. 그랬더니 나는 단순하게 Rand() 함수라던가.. 를 생각했는데 무슨 메르센 트위스터 알고리즘을 이용한 난수 생성기를 이용하는게 좋다더라..... 당최 무슨 소린지 모르겠지만 일단 써보고 랜덤을 사용해야할 경우에 계속 사용하다보면 익숙해지지 않을까 싶다.............

사용법

// 하드웨어 기반 난수 생성 시드
static std::random_device rd;

// tm19937 = 난수엔진
// 메르센 트위스터 알고리즘을 사용함
// gen(seed)를 통해 생성 > gen(rd())
static std::mt19937 gen(rd());

// 균등 분포 정수 생성기(?????)
// dist() 를 통해 범위 지정
static std::uniform_real_distribution<> dist(0, 2);

dungeonEventState = static_cast<DungeonEvent>(dist(gen))

0 > Nothing
1 > EncounterEnemy
2 > FindTreasure

static 키워드

static은 lifetime과 scope를 고정한다.

함수 내부 static

void A()
{
    static int a = 10; // 함수 끝나도 살아있음
}

최초 1회만 초기화 가능하며 함수 호출이 끝나면 값이 살아있다.

class 내부 static

class A 
{
    static int count; // 해당 class로 생성된 객체와 모두 공유됨
}

A a;
A b;

a.count // 10
b.count // 10

//하지만 static 멤버변수 호출은 아래가 정석 다 공유되니까!
A::count  // 10

📅 2026-04-29

Directory 구조

C++에서 어떤 구조가 좋을지는 아직 학습을 못해서 일단 생각대로 만들어보려고 한다. main() 함수는 TextRPG.cpp 안에 있다.

main() 함수는 오직 GameStart() 함수만 담고있다.

GameState 및 선택지 분기처리

여러 방법이 떠올랐는데 가장 기본적으로는 cin으로 입력받고 switch/case로 분기하는 것이었다.

근데 뭔가 최선은 아닌 듯 해서 방법을 찾아보니 Function Map이라는 자료구조가 있다는 걸 알게됐다.

Function Map

입력 값(key)에 따라 실행할 함수를 연결 해놓은 자료구조

switch (input)
{
case '1': Attack(); break;
case '2': Defend(); break;
}

위와같은 switch case를 데이터 구조로 변경한 것이다.

사용법

#include <map>
#include <functional>

// 선언
std::map<char, std::function<void()>> funcMap;

실사용 예제

#include <iostream>
#include <functional>
#include <map>

void Attack() { std::cout << "Attack"; } 
void Defend() { std::coud << "Defend"; }

void main()
{
    std::map<char, std::function<void()>> funcMap;

    funcMap['q'] = Attack;
    funcMap['w'] = Defend;

    char input;

    std::cin >> input;

    funcMap[input]();
}

결과적으로 함수를 값처럼 사용할 수 있다는 점에서 Delegate와 비슷하지만 이벤트 시스템은 직접 구현해야된다거나 하는 점에서 Delegate는 상위 개념으로 볼 수 있다.

그리고 코드를 딱 보면 알겠지만 switch/case 쓰는 것 보다 코드가 클린해진다.

그리고 이후 입력>출력 데이터 추가에도 매우 용이하다.

가상함수

Stat SetBaseStat() const override

override 부모클래스의 가상함수를 재정의 하겠다는 뜻

virtual Stat SetBaseStat() const = 0;

= 0 하는 이유 > 이유없음 그냥 C++ 문법 얘는 순수가상함수다 라는걸 나타냄

내일 GameState > GetPlayerCharacter부터 시작

📅 2026-04-28

언리얼에서 C++로 액터클래스 생성

클래스 생성

에디터 > 상단 Tools > New C++ Class > Actor > MyActor로 생성

콘텐츠 브라우저에서 BP 생성

콘텐츠 브라우저 > 우클릭 > ALL CLASSES > MyActor 검색

Location이동 및 Rotation 구현

MyActor.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "MyActor.generated.h"

UCLASS()
class PROJECT1TOGETHER_API AMyActor : public AActor
{
    GENERATED_BODY()

public:    
    // Sets default values for this actor's properties
    AMyActor();

    FVector PrevLocation;
    FVector CurrentLocation;
    float TotalDistance;
    int MoveCount;

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

public:    
    // Called every frame
    virtual void Tick(float DeltaTime) override;



    void Move();
    void Turn();
    void TriggerEvent();
};

MyActor.cpp

#include "MyActor.h"

// Sets default values
AMyActor::AMyActor()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
}

// Called when the game starts or when spawned
void AMyActor::BeginPlay()
{
    Super::BeginPlay();

}

// Called every frame
void AMyActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

void AMyActor::Move()
{
    FVector Target;

    // -50 ~ 50 randomeFloat
    Target.X = FMath::FRandRange(-50.0, 50.0);
    Target.Y = FMath::FRandRange(-50.0, 50.0);
    Target.Z = 0;

    AddActorWorldOffset(Target);

}

void AMyActor::Turn()
{
    FRotator DeltaRotation;

    DeltaRotation.Yaw = FMath::FRandRange(-180.0, 180.0);
    DeltaRotation.Pitch = 0;
    DeltaRotation.Roll = 0;

    AddActorWorldRotation(DeltaRotation);
}

과제 1

• 1. 이동할 때마다 좌표, MoveCount 출력
• 2. 50% 확률 이동
• 3. 10회 이동 후 최종결과 리포트

MyActor.h

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

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "MyActor.generated.h"

UCLASS()
class PROJECT1TOGETHER_API AMyActor : public AActor
{
    GENERATED_BODY()

public:    
    // Sets default values for this actor's properties
    AMyActor();

    FVector PrevLocation;
    FVector CurrentLocation;
    float TotalDistance;
    int MoveCount;

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

public:    
    // Called every frame
    virtual void Tick(float DeltaTime) override;



    void Move();
    void Turn();
    void TriggerEvent(int key);
};

MyActor.cpp

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


#include "MyActor.h"

// Sets default values
AMyActor::AMyActor()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
    TotalDistance = 0.0f;
    MoveCount = 0;
}

// Called when the game starts or when spawned
void AMyActor::BeginPlay()
{
    Super::BeginPlay();
    PrevLocation = GetActorLocation();

    for (int32 i = 0; i < 10; i++)
    {
        bool CanMove = FMath::RandBool();
        if (CanMove)
        {
            TriggerEvent(i);
        }
    }
}

// Called every frame
void AMyActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

void AMyActor::Move()
{
    FVector Target;

    // -50 ~ 50 randomeFloat
    Target.X = FMath::FRandRange(-50.0, 50.0);
    Target.Y = FMath::FRandRange(-50.0, 50.0);
    Target.Z = 0;

    AddActorWorldOffset(Target);

}

void AMyActor::Turn()
{
    FRotator DeltaRotation;

    DeltaRotation.Yaw = FMath::FRandRange(-180.0, 180.0);
    DeltaRotation.Pitch = 0;
    DeltaRotation.Roll = 0;

    AddActorWorldRotation(DeltaRotation);
}

void AMyActor::TriggerEvent(int key)
{
    int32 BaseCountKey = MoveCount * 10 + key ;
    MoveCount++;
    Move();
    Turn();
    CurrentLocation = GetActorLocation();
    TotalDistance += FVector::Dist(PrevLocation,CurrentLocation);


    if (GEngine)
    {
        GEngine -> AddOnScreenDebugMessage(BaseCountKey + 1, 5, FColor::Red, FString::Printf(TEXT("Prev: %ls"),*PrevLocation.ToString()));
        GEngine -> AddOnScreenDebugMessage(BaseCountKey + 2, 5, FColor::Red, FString::Printf(TEXT("Current: %ls"),*CurrentLocation.ToString()));
        GEngine -> AddOnScreenDebugMessage(BaseCountKey + 3, 5, FColor::Red, FString::Printf(TEXT("TotalDist: %f"),TotalDistance));
        GEngine -> AddOnScreenDebugMessage(BaseCountKey + 4, 5, FColor::Red, FString::Printf(TEXT("MoveCount: %d"),MoveCount));
    }


    UE_LOG(LogTemp, Warning, TEXT("Init: %s"), *PrevLocation.ToString());
    UE_LOG(LogTemp, Warning, TEXT("Current: %s"), *CurrentLocation.ToString());
    UE_LOG(LogTemp, Warning, TEXT("Acc: %f"), TotalDistance);
    UE_LOG(LogTemp, Warning, TEXT("MoveCount: %d"), MoveCount);

    PrevLocation = CurrentLocation;
}

결과

에디터 종료 후 액터 재생성 오류

언리얼 에디터 + Rider로 신나게 작업하다가 에디터, Rider 닫고 재시작을 했더니 레벨에서 액터가 사라지고 BP_MyActor를 드래그앤드랍으로 배치시 실패 오류 로그가 발생한다.

튜터님께 질문드린결과 실무에서도 C++ 프로젝트 열때 Rider에서 여는게 일반적이라고 알려주셨다.

에디터에서 열 경우 에디터 하단 Contents Browser에 C++ Classes 폴더가 없는데 이는 C++ 컴파일이 되지 않아서 인식해지 못해서 발생한다고 생각했다.

그래서 튜터님 말씀대로 언리얼과 Rider를 종료하고 Rider로 프로젝트를 연 뒤 우측 상단 프로젝트명 옆 실행 버튼이 활성화될 때 까지 기다렸다가 누르면 빌드가 시작되면서 언리얼에디터가 열리는데

이때 문제가 해결된 것을 볼 수 있다. 이때부터는 에디터부터 열어도 오류가 발생하지 않는다.

git init 해당 폴더를 레포지토리에 업로드 하고싶어요.

git repository에 push하기 위해 initializing

git add README.md 이 저장소는 ~를 위한 저장소입니다. 사용법은 아래와 같습니다.

git repository 사용 설명서 추가

git add <file-name> 해당 commit에는 이런 파일들이 변경(생성, 추가, 삭제 등)되었습니다.

commit할 파일들 선택

git commit -m "first commit" 해당 커밋은 "first commit" 이라는 내용이 변경되었습니다.

repository에 push하기 전 업로드할 파일 확정

git branch -M main main이라는 브랜치를 만들어서 해당 브랜치를 master branch로 설정할께요.

해당 레포지토리의 master branch를 생성 이름은 main

git remote add origin https://github.com/Carrymachine/Test.git 앞으로 수정되는 내용들은 모두 여기에 업로드할께요.

업로드할 주소를 origin이라는 이름으로 추가할께요.

git push -u origin main origin의 main 브랜치에 업로드해주세요.

origin의 main 브랜치에 push -u는 업스트림인데 신경안써도 무방

git switch -c "브랜치 명" 현재 기준의 코드베이스에서 "브랜치 명"으로 브랜치 생성 후 이동할께요.

(main에서 명령어 입력 시) main을 기준으로 "브랜치 명"의 브랜치를 생성후 이동

git pull
또는
git pull <브랜치 명>

현재 선택된 브랜치의 내용을 현재 코드베이스로 가져올께요.

(git pull만 할 경우) 현재 브랜치의 코드베이스 pull (<브랜치 명>함께 입력 시) 현재 브랜치에 <브랜치 명> 코드베이스 pull