📅 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

📅 2026-04-24~27

플레이영상

C++ 문법 공부

지금 그거할 시간이 없어!!!!!

플레이 화면 맛보기

UI

맵

플레이어

캐릭터

기본조작

앉기

격발, 재장전

FireOnce

Reload

정조준

피해 입었을 경우

사망

적 AI

캐릭터

랜덤 이동

추적

격발

피해 입었을 경우

사망

총기(밴달)

에셋

에미터, 나이아가라 시스템

📅 2026-04-23

C++ 문법 공부

오늘 안했다 FPS 제작 개꿀잼

FPS 제작

Animation Montage

그동안은 ABP 안에서 Statemachine으로 각 애니메이션들의 상태들을 관리햇었다.

그러다보니 노드가 필요이상으로 커지기도 하고 FPS에서 필요한 여러 상태들(대기, 걷기, 뛰기, 앉기, 격발, 재장전 등)이 얽혀서 재장전이 씹힌다거나 총을 쏘면서 재장전을 한다던가 재장전중인데 모션이 안나온다던가 온갖 버그가 나왔다.

그래서 공식문서를 보던 중 Animation Montage라는 걸 발견했는데

쉽게 말하면 강제재생이다.

그래서 단발성 애니메이션인 격발모션, 재장전 등에 사용해봤다.

Montage 생성

우클릭 > animation > animation montage에서 생성 가능하다.

스켈레톤매시를 설정 후 들어가서 Montage Manager > Add Montage > slot 추가

일반 애니메이션 시퀀스처럼 notify도 전달할 수 있다.

AnimGrahp

그후 애님그래프에서 우클릭 > slot 'defaultGroup' > 디테일에서 설정해준 슬롯으로 변경하면 끝이다. 이제 몽타주를 사용해보자.

Montage 사용

우클릭 > Montage Play 노드 > target 및 몽타주 지정 하면 끝이다.

이러면 특정 로직을 통해 애니메이션 실행이 가능하고 강제로 실행된다. 중간에 변경되는 state나 이런 부분들은 잘 예외처리 해주면 된다.

그리고 강제로 실행하는 만큼 강제로 멈출 수도 있는데 Montage Stop 노드를 사용하면 된다.

📅 2026-04-22

C++ 문법 공부

C++템플릿

FPS 제작

발로란트 좋아해서 발로란트 스타일로 만들어보고 있다.

오전 1시간동안 코드카타를 하는데 아직 그럴 실력이 안돼서 일단 문법 공부를 더 해보려고한다.

템플릿

타입을 매개변수로 받는 코드 생성 매커니즘이다. 컴파일 타임에 타입별 코드를 생성하는 시스템이라고 생각하면 좋다. TS를 하던 내 입장에서는 제네릭이라고 생각하니까 이해가 편했다.

• 컴파일 타임에 동작
• 타입 안정성 보장
• 런타임 오버헤드 없음

template<typename T>
T Add(T a, T b)
{
    return a + b;
}

>> 컴파일 시

int Add (int a, int b)
{ ... }

float Add ( float a, float b)
{ ... }

왜 필요한가?

타입 안전 + 성능 확보

• void*, 캐스팅 필요없음
• 컴파일 타임 체크
• inline 최적화 가능

  가상함수보다 빠름

추상화 수준 상승

• 제네릭 프로그래밍
• 자료구조/알고리즘을 타입과 분리

코드 재사용

여러 타입에서 같은 로직 사용

사용 예시

함수 템플릿

template<typename T>
T Max(T a, T b)
{ ... }

클래스 템플릿

template<typename T>
class Box
{
public:
    T value;
}


Box<int> a;
Box<float> b;

STL

std::vector<int> v;
std::sort(v.begin(), v.end());

• vector<T> > 타입별 컨테이너 생성
• sort<T> > 타입에 맞는 정렬코드 생성

템플릿 특수화

template<>
class Box<bool>
{ ... }

특정 타입에 대해 다르게 동작하도록 커스터마이징 특정 타입에 대해 다르게 동작하도록 커스터마이징

2개 이상의 타입

template<typename T, typename K, typename F ... >
class Test
{
public:
    T First;
    K Second;
    F Third;
    ...
}

Test<int, float, double> a;

가변템플릿

template<typename... Args>

• 템플릿 코드 폭발 방지 없으면 아래와 같이 모두 만들어줘야함

  Print(T);
  Print(T, K);
  Print(T, K, F);
  ...

가변 템플릿은 쓸 내용이 많아서 나중에 다시 한번 공부할 예정

📅 2026-04-21

C++ 문법 공부

스마트 포인터

FPS 제작

발싸-!

수업시간에 들은 것 따라가면서 시간이 남아서 발로란트의 밴달 연사를 구현해봤다. 이펙트나 나머지는 내일 진행해볼 예정

함수화

블프에서 노드가 많아지니까 아무래도 함수를 자주 사용하게된다.

라인트레이스

FPS에서 빠지면 안되는 그것...

일반적으로 실질적인 라인트레이스는 카메라기준 이펙트나 다른 부가적인 것들은 머즐을 기준으로 하면 될 것 같다.

줌인아웃

많은 FPS에서 지원하는 정조준 사격 모드 온오프 기능 애니메이션까지 넣으면 매우 그럴듯해 보일 것 같다.

결과물

튜터님이 검색해보라고 한 것 주말에 꼭 보기

Cascadeur

Procedurally Animating

game animation sample(unreal)

meta human

오전 1시간동안 코드카타를 하는데 아직 그럴 실력이 안돼서 일단 문법 공부를 더 해보려고한다.

스마트 포인터

19일 작성한 RAII 패턴 기반의 포인터 래퍼이다. 사용하는 목적은 수동으로 해주던 new/delete의 할당/해제를 자동으로 해준다. 또한 소유권을 명확하게 하는데 의의가 있다.

왜 필요한가?

일반 포인터는 주소를 담고 있다는 사실을 알고있다. 하지만

• 누가 해제해야하는지
• 언제 소멸하는지
• 소유권이 누구한테 있는지

이게 코드만 보고 명확하지 않다. 그래서 이중 해제, 누수, dangling pointer가 생긴다. C++ 가이드라인에서 소유권이 필요하면 스마트 포인터, 소유권 자체가 필요없다면 일반 값이나 참조, 일반 포인터가 더 적절하다고 한다.

dangling pointer?

이미 해제된 메모리 영역을 가르키는 포인터를 말함

• 포인터가 주소를 가지고있음
• 근데 그 주소는 이미 해제됨
• 정의되지 않은 동작 발생할 확률 증가

메모리 해제 후 포인터 유지

int* p = new int(10);

delete p; // p는 아직 주소 가지고 있음

지역 변수 주소 반환

function RtrnPointer()
{
    int x = 10;

    return &x; // 함수가 끝나면 지역변수 사라짐
}

객체 소멸 후 참조 유지

int* p;


function RtrnPointer()
{
    int x = 10;
    p = &x;w
} // x소멸

단일소유권 std::unique_ptr

std::unique_ptr<int> p = std::make_unique<int>(10);

하나의 객체만 특정 자원을 소유하는 구조.

• 스코프를 벗어남.
• reset()
• 다른 포인터로 재대입 위 3가지 경우에 관리 대상이 삭제된다. 또한 커스텀 deleter를 둘 수 있고 move가능 copy 불가능하다.

move와 copy?

// copy 
std::unique_ptr<int> p1 = std::make_unique<int>(10);
std::unique_ptr<int> p2 = p1; // 컴파일 에러

// move
std::unique_ptr<int> p1 = std::make_unique<int>(10);
std::unique_ptr<int> p2 = std::move(p1);

공유소유권 std::shared_ptr

#include <memory>

std::shared_ptr<int> p1 = std::make_shared<int>(10);
std::shared_ptr<int> p2 = p1; // 공동소유

shared_ptr는 여러 포인터가 같은 객체를 공동 소유한다. 같은 객체를 소유한 여러 포인터 중 마지막 포인터가 소멸되거나 다른 대상으로 지정되면 객체가 삭제된다.

왜 필요한가?

• 여러 객체/시스템이 실제로 같은 대상을 함께 소유해야할 경우
• 소유자가 동적으로 늘어나거나 줄어들어서 하나로 정하기 애매할 때
• 콜백, 비동기, 옵저버 패턴에서 수명 연장이 명시적으로 필요할 때

주의

자칫 소유권이 불명확한 설계를 덮어버리는 도구가 되기 쉽다. 공유 포인터는 런타임 코스트를 수반하므로 자제하는게 좋다.

감시 std::weak_ptr

#include <memory>


std::shared_ptr<int> sp = std::make_shared<int>(10);
std::weak_ptr<int> wp = sp;

if (auto locked = wp.lock())
{ ... }

weak_ptr은 shared_ptr이 관리하는 객체를 소유하지 않고 가리키기만 한다.

역참조가 불가능하며 lock()으로 임시로 shared_ptr을 얻어서 사용해야한다. 또한 expired()로 삭제 됐는지 확인이 가능하다.

왜 필요한가?

가장 대표적인 이유는 순환참조 방지이다.

struct B;

struct A
{
    std::shared_ptr<B> b;
}

struct B
{
    std::shared_ptr<A> a; // 서로 shared_ptr이면 해제 안됨
}

위의 구조는 서로가 서로를 소유해서 참조 카운트가 0이 안된다. 때문에 메모리 릭이 발생하는데 이렇게 설계해야할 경우 한쪽을 weak으로 끊으면 된다.

• 부모-자식, 옵저버, 이벤트리스너처럼 연결을 필요하지만 소유는 아닐경우
• 캐시나 백 레퍼런스
• shared_ptr 구조에서 순환참조 방지

📅 2026-04-20

원래 썸네일로 쓰던 학습시간이 오늘부터는 12시간으로 고정이라 이제 시간만 더하고 썸네일은 달지 않을 예정입니다. (아쉽네요)

C++ 문법 공부

C와 C++의 동적할당 차이점

라인트레이스

쉽게 라인을 발사해서 부딪히는 것을 검출 x-ray처럼 관통 검출도 가능(멀티-라인트레이스)

레벨

우선 블루프린트 > 게임모드로 하나 생성해준다 이름은 BP_GameMode

이후 2개의 함수 생성

Load AILevel

UnLoad AILevel

불러올 레벨을 만들고 AI 액터를 넣어준다.

큐브 액터를 만들고 레벨을 로드 해보자. 난 캐릭터가 상자에 충돌했을 경우 레벨을 로드하려고한다.

레벨이 로드되면 Hello 스트링을 프린트하도록 했는데 그림자분신술을 써버린다.

캠프에서 C언어 완전 기초.. 부터 수업을 하길래 생각난 김에 차이에 대해서 공부해보려고 하다가 동적할당이라는 주제를 선택했다.

핵심적인 차이점

C

단순 메모리 확보/해제

C++

객체의 생성/소멸까지 포함된 메모리 관리

문법

C

int* arr = (int*)malloc(sizeof(int) * 10);
free(arr);

C++

int* arr = new int[10];
delete[] arr;

생성자 / 소멸자 호출 여부

C

생성자/소멸자 없이 메모리 덩어리

C++

class A
{
    A() { printf("생성"); }
    ~A() { printf("소멸"); }
}

A* a = new A();
delete a;

타입 안정성

C

void* ptr = malloc(sizeof(int));
int* iptr = (int*)ptr; // 캐스팅 필요

• 타입정보 X
• 캐스팅 실수해도 컴파일에러X

C++

int* ptr = new int;

• 타입 자동 추론
• 캐스팅 필요없음
• 컴파일 시 타입체크

초기화

C

int* a = (int*)malloc(sizeof(int)); // 더미값

C++

int* a = new int(); // 0 초기화
int* b = new int(10); // 값 지정 가능

배열처리

C

int* arr = (int*)malloc(sizeof(int) * 10);
free(arr);

C++

int* arr = new int[10];
delete[] arr;

실패처리

C

if (ptr == NULL) { ... }

C++

int* ptr = new int; // 실패시 예외 발생

설계관점

C

• 단순 구조체 + 메모리
• 사람이 직접 관리
• 휴먼에러 확률 높음

C++

• 객체중심
• 생성/소멸 자동 관리 (stl)
• RAII 패턴 사용

RAII란?

메모리 자동 해제까지 염두하는 설계법

class string
{
public:
    char* c = nullptr;

    string(size_t len)
    {
        c = new char[len];
    }

    ~string()
    {
        delete[] c;
    }
};

string s(100);
strcpy(s.c, "Hello, world!");
throw 0;

// 출처 : https://m.blog.naver.com/kmc7468/220927032462

std::shared_ptr, std::unique_ptr 등 모두 RAII 패턴으로 작성됨

따라서

모던C++에서는 STL 사용하는게 정석

그럼에도 C++에서 직접 메모리 관리를 하는 경우

C 라이브러리와 연동 시

C API는 malloc/free로 작성되어 있어서

매우매우 로우레벨 메모리 제어 시(게임/엔진/시스템)

• 메모리 풀
• 커스텀 allocator
• 성능 튜닝

📅 2026-04-16

복습 및 퀘스트

장애물 피하기를 만들었다.

골렘에 AI를 적용해 랜덤한 X값으로 이동하게 만들었다.

골렙과 충돌 시 터지는 이펙트와 함께 사망 UI가 발생한다. (UI 수정 도중 찍어서 얼라인이 안맞는다.)