코드망령

언리얼 C++ 과제 4

코드망령 — Tue, 9 Jun 2026 13:23:42 +0900

스파르타 클럽 챕터3 과제4 진행

Pawn으로 이동하는 객체 만들기와 도전과제로 비행체 만들기입니다.

https://www.youtube.com/watch?v=qnovx8h6Qr8

Pawn에 걷기, 점프, 달리기를 추가했고, 추가적으로 Pawn클래스를 하나 더 만들어 비행체를 구현했습니다.

이동과 화면회전은 AddActorLocalLocation과 AddActorLocalRotation으로 구현했습니다.

Character클래스의 경우는 이동할 때 바닥이나 벽면에서 Block되었어도 미끄러지도록 구현이 되어있지만

Pawn의 경우 그런 물리로직을 직접 구현해야 했습니다.

SpartaPawn.h

#pragma once

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

class UCameraComponent;
class UCapsuleComponent;
class USkeletalMeshComponent;
class USpringArmComponent;
class USpartaMoveComponent;
struct FInputActionValue;

UCLASS()
class SPARTA3_4_API ASpartaPawn : public APawn
{
	GENERATED_BODY()

public:
	ASpartaPawn();

	UPROPERTY(EditAnywhere)
	UCapsuleComponent* Capsule;
	UPROPERTY(EditAnywhere)
	USkeletalMeshComponent* SkeletalMesh;
	UPROPERTY(EditAnywhere)
	USpringArmComponent* SpringArm;
	UPROPERTY(EditAnywhere)
	UCameraComponent* Camera;
	UPROPERTY(EditAnywhere)
	USpartaMoveComponent* MoveComponent;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Look")
	float LookSensitivity = 90.f;
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Look")
	float MinPitch = -50.f;
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Look")
	float MaxPitch = 40.f;

	UFUNCTION(BlueprintCallable)
	USpartaMoveComponent* GetMoveComponent() { return MoveComponent; }
	
protected:
	virtual void BeginPlay() override;
	virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

public:
	virtual void Tick(float DeltaTime) override;

private:
	FVector2D LookInput = FVector2D::ZeroVector;
	float CurrentPitch = 0.f;

	void Move(const FInputActionValue& Value);
	void Look(const FInputActionValue& Value);
	void StartJump(const FInputActionValue& Value);
	void StopJump(const FInputActionValue& Value);
	void StartSprint(const FInputActionValue& Value);
	void StopSprint(const FInputActionValue& Value);

	void UpdateLook(float DeltaTime);
};

SpartaPawn.cpp

#include "SpartaPawn.h"

#include "EnhancedInputComponent.h"
#include "SpartaPlayerContrller.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "Components/SkeletalMeshComponent.h"
#include "GameFramework/SpringArmComponent.h"
#include "SpartaMoveComponent.h"

/*
 * Pawn의 역할
 *
 * 이 클래스는 플레이어의 컴포넌트 구성과 입력 연결을 담당합니다.
 * 실제 이동, 점프, 중력, 벽 슬라이딩은 USpartaMoveComponent에서 처리합니다.
 *
 * 카메라 회전은 여기서 직접 처리합니다.
 * - 마우스 X: Pawn 전체를 좌우(Yaw) 회전
 * - 마우스 Y: SpringArm만 위아래(Pitch) 회전
 *
 * 이렇게 나누면 Capsule은 항상 똑바로 서 있고,
 * 카메라만 위아래로 움직이는 Character 같은 시점을 만들 수 있습니다.
 */
ASpartaPawn::ASpartaPawn()
{
	PrimaryActorTick.bCanEverTick = true;

	// Capsule은 RootComponent이며, 플레이어 이동 충돌을 담당합니다.
	Capsule = CreateDefaultSubobject<UCapsuleComponent>(TEXT("Capsule"));
	SetRootComponent(Capsule);
	Capsule->InitCapsuleSize(42.f, 96.f);
	Capsule->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
	Capsule->SetCollisionResponseToAllChannels(ECR_Block);
	Capsule->SetSimulatePhysics(false);
	
	// SkeletalMesh는 화면에 보이는 용도만 담당하고, 충돌은 Capsule만 사용합니다.
	SkeletalMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("Skeleton"));
	SkeletalMesh->SetupAttachment(Capsule);
	SkeletalMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
	SkeletalMesh->SetSimulatePhysics(false);

	// SpringArm은 카메라의 위아래 회전을 담당합니다. Pawn 본체는 위아래로 기울이지 않습니다.
	SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("Spring Arm"));
	SpringArm->AttachToComponent(Capsule, FAttachmentTransformRules::KeepRelativeTransform);
	SpringArm->SetRelativeLocation(FVector(0.f, 0.f, 70.f));
	SpringArm->SetRelativeRotation(FRotator(CurrentPitch, 0.f, 0.f));
	SpringArm->TargetArmLength = 500.f;
	SpringArm->bUsePawnControlRotation = false;
	SpringArm->bDoCollisionTest = false;

	// Camera는 SpringArm 소켓에 붙어 SpringArm 끝 위치를 따라갑니다.
	Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
	Camera->SetupAttachment(SpringArm, USpringArmComponent::SocketName);
	Camera->SetRelativeLocation(FVector::ZeroVector);
	Camera->SetRelativeRotation(FRotator::ZeroRotator);
	Camera->bUsePawnControlRotation = false;

	// 실제 이동, 점프, 중력, 벽 슬라이딩은 MoveComponent에서 처리합니다.
	MoveComponent = CreateDefaultSubobject<USpartaMoveComponent>(TEXT("MoveComponent"));
	MoveComponent->UpdatedComponent = Capsule;

	bUseControllerRotationPitch = false;
	bUseControllerRotationYaw = false;
	bUseControllerRotationRoll = false;
}

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

}

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

	UpdateLook(DeltaTime);
}


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

	// Pawn은 Enhanced Input을 받고, 이동 관련 입력은 MoveComponent로 전달합니다.
	if (UEnhancedInputComponent* EnhancedInput = Cast<UEnhancedInputComponent>(PlayerInputComponent))
	{
		if (ASpartaPlayerContrller* PlayerController = Cast<ASpartaPlayerContrller>(GetController()))
		{
			EnhancedInput->BindAction(PlayerController->MoveAction, ETriggerEvent::Triggered, this, &ASpartaPawn::Move);
			EnhancedInput->BindAction(PlayerController->MoveAction, ETriggerEvent::Completed, this, &ASpartaPawn::Move);
			EnhancedInput->BindAction(PlayerController->LookAction, ETriggerEvent::Triggered, this, &ASpartaPawn::Look);
			EnhancedInput->BindAction(PlayerController->LookAction, ETriggerEvent::Completed, this, &ASpartaPawn::Look);
			EnhancedInput->BindAction(PlayerController->JumpAction, ETriggerEvent::Triggered, this, &ASpartaPawn::StartJump);
			EnhancedInput->BindAction(PlayerController->JumpAction, ETriggerEvent::Completed, this, &ASpartaPawn::StopJump);
			EnhancedInput->BindAction(PlayerController->SprintAction, ETriggerEvent::Triggered, this, &ASpartaPawn::StartSprint);
			EnhancedInput->BindAction(PlayerController->SprintAction, ETriggerEvent::Completed, this, &ASpartaPawn::StopSprint);
		}
	}
}


void ASpartaPawn::Move(const FInputActionValue& Value)
{
	// 이동 입력값만 MoveComponent에 넘기고, 실제 이동은 MoveComponent Tick에서 처리합니다.
	if (MoveComponent)
	{
		MoveComponent->SetMoveInput(Value.Get<FVector2D>());
	}
}

void ASpartaPawn::Look(const FInputActionValue& Value)
{
	// 마우스 입력값은 저장해두고 Tick에서 DeltaTime을 곱해 회전 처리합니다.
	LookInput = Value.Get<FVector2D>();
}

void ASpartaPawn::StartJump(const FInputActionValue& Value)
{
	if (MoveComponent)
	{
		MoveComponent->StartJump();
	}
}

void ASpartaPawn::StopJump(const FInputActionValue& Value)
{
	if (MoveComponent)
	{
		MoveComponent->StopJump();
	}
}

void ASpartaPawn::StartSprint(const FInputActionValue& Value)
{
	if (MoveComponent && Value.Get<bool>())
	{
		MoveComponent->StartSprint();
	}
}

void ASpartaPawn::StopSprint(const FInputActionValue& Value)
{
	if (MoveComponent)
	{
		MoveComponent->StopSprint();
	}
}

void ASpartaPawn::UpdateLook(float DeltaTime)
{
	if (LookInput.IsNearlyZero()) return;

	// 마우스 X축은 Pawn 전체를 좌우(Yaw)로 회전시킵니다.
	// 이 회전은 이동 방향에도 영향을 줍니다. Forward/Right 벡터가 같이 바뀌기 때문입니다.
	const float Yaw = LookInput.X * LookSensitivity * DeltaTime;
	AddActorLocalRotation(FRotator(0.f, Yaw, 0.f), false);

	// 마우스 Y축은 SpringArm만 위아래(Pitch)로 회전시켜 Capsule은 항상 똑바로 서 있게 합니다.
	// CurrentPitch를 제한해서 카메라가 너무 위나 아래로 꺾이지 않게 합니다.
	CurrentPitch = FMath::Clamp(
		CurrentPitch - LookInput.Y * LookSensitivity * DeltaTime,
		MinPitch,
		MaxPitch
	);

	if (SpringArm) SpringArm->SetRelativeRotation(FRotator(CurrentPitch, 0.f, 0.f));
	
}

SpartaMoveComponent.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/PawnMovementComponent.h"
#include "SpartaMoveComponent.generated.h"

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class SPARTA3_4_API USpartaMoveComponent : public UPawnMovementComponent
{
	GENERATED_BODY()

public:
	USpartaMoveComponent();

	// 기본 이동 속도입니다. Unreal 단위 기준으로 초당 이동 거리입니다.
	UPROPERTY(EditAnywhere, Category = "Move")
	float MoveSpeed = 450;
	// 달리기 입력이 켜져 있을 때 MoveSpeed에 곱해지는 값입니다.
	UPROPERTY(EditAnywhere, Category = "Move")
	float SprintMultiplier = 2.5f;
	// 점프를 시작할 때 위쪽으로 주는 초기 속도입니다.
	UPROPERTY(EditAnywhere, Category = "Jump")
	float JumpPower = 800.f;
	// 공중에 있을 때 매 프레임 아래쪽으로 누적되는 중력 가속도입니다.
	UPROPERTY(EditAnywhere, Category = "Physics")
	float Gravity = 980.f;
	// Pawn 중심에서 아래로 레이를 쏴서 바닥을 찾는 거리입니다.
	UPROPERTY(EditAnywhere, Category = "Physics")
	float GroundCheckDistance = 120.f;
	// 이 값보다 Normal.Z가 크면 걸을 수 있는 바닥이나 경사로 판단합니다.
	UPROPERTY(EditAnywhere, Category = "Physics")
	float WalkableFloorZ = 0.6f;

	// 이동 및 달리기 애니메이션을 위한 값을 반환합니다.
	UFUNCTION(BlueprintCallable)
	bool IsMove() { return MoveInput.IsNearlyZero(); }
	// 점프하는 애니메이션을 위한 값을 반환합니다.
	UFUNCTION(BlueprintCallable)
	float GetVerticalVelocity() { return VerticalVelocity; }
	// 떨어지는 애니메이션을 위한 값을 반환합니다.
	UFUNCTION(BlueprintCallable)
	bool GetIsGrounded() { return bIsGrounded; }
	// 달리는 애니메이션을 위한 값을 반환합니다.
	UFUNCTION(BlueprintCallable)
	bool GetIsSprinting() { return bIsSprinting; }
	
protected:
	virtual void BeginPlay() override;
	virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

public:
	void SetMoveInput(const FVector2D& Value);

	void StartJump();
	void StopJump();

	void StartSprint();
	void StopSprint();
private:
	// 매 Tick마다 GetOwner, FindComponent를 반복하지 않기 위해 캐싱합니다.
	UPROPERTY()
	APawn* CachedOwnerPawn = nullptr;
	UPROPERTY()
	UCapsuleComponent* CachedCapsule = nullptr;
	// 현재 밟고 있는 Actor입니다. 움직이는 발판을 따라가기 위해 사용합니다.
	UPROPERTY()
	AActor* GroundActor = nullptr;

	// Pawn의 Enhanced Input 함수에서 받은 이동 입력값을 저장합니다.
	FVector2D MoveInput = FVector2D::ZeroVector;

	// CharacterMovement를 쓰지 않기 때문에 Z축 속도를 직접 관리합니다.
	float VerticalVelocity = 0.f;
	// Capsule이 현재 바닥 위에 정확히 서기 위한 ActorLocation.Z 값입니다.
	float GroundZ =0.f;
	// 기본이동값과 달리기의 값을 저장하기 위한 변수입니다.
	float CurrentSpeed = 0.f;
	// 현재 밟고 있는 바닥의 Normal입니다. 울퉁불퉁한 바닥을 따라 이동할 때 사용합니다.
	FVector GroundNormal = FVector::UpVector;
	// 이전 프레임의 GroundActor 위치입니다. 움직인 발판의 이동량을 계산합니다.
	FVector LastGroundActorLocation = FVector::ZeroVector;
	
	bool bIsGrounded = true;
	bool bIsSprinting = false;

	// 아래 방향 LineTrace로 바닥 여부, 바닥 Normal, 밟고 있는 Actor를 갱신합니다.
	void CheckGround();

	// 입력 이동, 중력, 점프 속도를 합친 뒤 Sweep 이동과 벽면 슬라이드를 처리합니다.
	void ApplyMovement(float DeltaTime);
	// 현재 밟고 있는 움직이는 발판의 이동량만큼 Pawn을 먼저 이동시킵니다.
	void ApplyGroundActorMovement();
};

SpartaMoveComponent.cpp

#include "SpartaMoveComponent.h"

#include "Components/CapsuleComponent.h"
#include "GameFramework/Pawn.h"

/*
 * 이 컴포넌트의 전체 이동 원리
 *
 * 1. Pawn에서 받은 입력값을 MoveInput에 저장한다.
 * 2. Tick마다 아래 순서로 이동을 처리한다.
 *    - 이전 프레임에 밟고 있던 발판이 움직였으면 Pawn도 먼저 따라간다.
 *    - 아래로 LineTrace를 쏴서 현재 바닥 상태를 확인한다.
 *    - 입력 이동, 점프 속도, 중력을 합쳐 이번 프레임 이동량을 만든다.
 *    - Capsule을 Sweep 이동시켜 벽이나 바닥에 부딪혔는지 확인한다.
 *    - 충돌했다면 SlideAlongSurface로 벽면이나 경사면을 따라 미끄러지게 한다.
 *
 * Simulate Physics는 사용하지 않는다.
 * 대신 직접 계산한 이동량 + Sweep 충돌 검사 + 바닥 레이 + 슬라이딩으로
 * CharacterMovement와 비슷한 동작을 흉내낸다.
 */

USpartaMoveComponent::USpartaMoveComponent()
{
	PrimaryComponentTick.bCanEverTick = true;
}

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

	CachedOwnerPawn = Cast<APawn>(GetOwner());
	if (CachedOwnerPawn)
	{
		CachedCapsule = CachedOwnerPawn->FindComponentByClass<UCapsuleComponent>();
		SetUpdatedComponent(CachedOwnerPawn->GetRootComponent());
		GroundZ = CachedOwnerPawn->GetActorLocation().Z;
	}
}

void USpartaMoveComponent::TickComponent(float DeltaTime, ELevelTick TickType,
	FActorComponentTickFunction* ThisTickFunction)
{
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

	if (!CachedOwnerPawn || !UpdatedComponent || ShouldSkipUpdate(DeltaTime))
	{
		return;
	}

	// 1. 지난 프레임에 밟고 있던 발판이 움직였다면 Pawn도 그만큼 먼저 따라갑니다.
	// CharacterMovement의 Movement Base 개념을 간단하게 흉내낸 부분입니다.
	ApplyGroundActorMovement();
	// 2. 현재 프레임 기준으로 바닥에 있는지, 바닥 Normal이 무엇인지 다시 확인합니다.
	CheckGround();
	// 3. 입력 이동, 중력, 점프, 충돌, 슬라이딩을 한 번에 처리합니다.
	ApplyMovement(DeltaTime);
}

void USpartaMoveComponent::SetMoveInput(const FVector2D& Value)
{
	MoveInput = Value;
}

void USpartaMoveComponent::StartJump()
{
	// 바닥에 있을 때만 점프를 시작합니다.
	// 점프는 실제 물리 힘이 아니라 VerticalVelocity 값을 직접 올리는 방식입니다.
	if (bIsGrounded)
	{
		VerticalVelocity = JumpPower;
		bIsGrounded = false;
	}
}

void USpartaMoveComponent::StopJump()
{
	// 점프 키를 떼면 상승 속도를 줄여서 짧은 점프가 가능하게 합니다.
	if (VerticalVelocity > JumpPower * 0.5f)
	{
		VerticalVelocity = JumpPower * 0.5f;
	}
}

void USpartaMoveComponent::StartSprint()
{
	bIsSprinting = true;
}

void USpartaMoveComponent::StopSprint()
{
	bIsSprinting = false;
}

void USpartaMoveComponent::CheckGround()
{
	if (!CachedOwnerPawn)
	{
		return;
	}

	UWorld* World = CachedOwnerPawn->GetWorld();
	if (!World)
	{
		return;
	}

	const FVector Start = CachedOwnerPawn->GetActorLocation();
	const FVector End = Start - FVector(0.f, 0.f, GroundCheckDistance);

	FHitResult Hit;
	FCollisionQueryParams Params(SCENE_QUERY_STAT(SpartaGroundCheck), false, CachedOwnerPawn);

	// CharacterMovement의 FloorCheck를 직접 흉내내는 부분입니다.
	// Pawn 중심에서 아래로 레이를 쏴서 걸을 수 있는 바닥인지 확인합니다.
	//
	// Hit.Normal.Z가 1에 가까우면 평평한 바닥이고,
	// 0에 가까우면 수직 벽입니다.
	// WalkableFloorZ 이상이면 걸을 수 있는 바닥이나 경사로 판단합니다.
	const bool bHit = World->LineTraceSingleByChannel(
		Hit,
		Start,
		End,
		ECC_Visibility,
		Params
	);

	if (bHit && Hit.Normal.Z >= WalkableFloorZ && VerticalVelocity <= 0.f)
	{
		bIsGrounded = true;
		// 바닥의 기울기를 저장해두면 이동 벡터를 바닥면에 맞춰 보정할 수 있습니다.
		GroundNormal = Hit.Normal;
		// Hit.ImpactPoint.Z는 바닥 표면 높이입니다.
		// Pawn의 ActorLocation은 Capsule 중심이므로 HalfHeight를 더해야 바닥 위에 서게 됩니다.
		GroundZ = Hit.ImpactPoint.Z + CachedCapsule->GetScaledCapsuleHalfHeight();
		// 바닥 Actor를 저장해두면, 다음 Tick에서 움직이는 발판의 이동량을 따라갈 수 있습니다.
		GroundActor = Hit.GetActor();
		if (GroundActor)
		{
			LastGroundActorLocation = GroundActor->GetActorLocation();
		}
	}
	else
	{
		bIsGrounded = false;
		GroundNormal = FVector::UpVector;
		GroundActor = nullptr;
	}
}

void USpartaMoveComponent::ApplyMovement(float DeltaTime)
{
	if (!CachedOwnerPawn || !UpdatedComponent)
	{
		return;
	}

	CurrentSpeed = bIsSprinting ? MoveSpeed * SprintMultiplier : MoveSpeed;

	// 바닥에 있을 때는 아래로 떨어지는 속도가 계속 누적되지 않도록 0으로 정리합니다.
	// 공중이면 매 프레임 중력을 빼서 위로 올라가던 속도가 줄고, 결국 아래로 떨어지게 합니다.
	if (bIsGrounded && VerticalVelocity < 0.f)
	{
		VerticalVelocity = 0.f;
	}
	else if (!bIsGrounded)
	{
		// 공중에 있을 때만 중력을 직접 적용합니다.
		VerticalVelocity -= Gravity * DeltaTime;
	}

	// MoveInput.X/Y를 Pawn의 Right/Forward 방향으로 변환해서 월드 이동량을 만듭니다.
	// X는 좌우, Y는 앞뒤 입력입니다.
	FVector WorldHorizontalDelta = CachedOwnerPawn->GetActorForwardVector() * MoveInput.Y;
	WorldHorizontalDelta += CachedOwnerPawn->GetActorRightVector() * MoveInput.X;
	WorldHorizontalDelta = WorldHorizontalDelta.GetClampedToMaxSize(1.f) * CurrentSpeed * DeltaTime;

	if (bIsGrounded)
	{
		// 바닥면에 이동 벡터를 투영합니다.
		// 이렇게 해야 울퉁불퉁한 바닥이나 경사에서 이동 방향이 바닥을 따라갑니다.
		// 즉, 바닥 안으로 파고드는 성분은 제거하고 바닥 표면을 따라가는 성분만 남깁니다.
		WorldHorizontalDelta = FVector::VectorPlaneProject(WorldHorizontalDelta, GroundNormal);
	}

	// 수평 입력 이동량과 수직 점프/중력 이동량을 합쳐 이번 프레임 최종 이동량을 만듭니다.
	const FVector WorldVerticalDelta(0.f, 0.f, VerticalVelocity * DeltaTime);
	const FVector DesiredDelta = WorldHorizontalDelta + WorldVerticalDelta;

	if (DesiredDelta.IsNearlyZero())
	{
		return;
	}

	FHitResult Hit;
	// Capsule을 Sweep 이동합니다.
	// 단순 순간이동이 아니라 이동 경로에 벽/바닥이 있으면 Hit에 충돌 정보가 들어옵니다.
	// Sweep은 물리 시뮬레이션이 아니라 충돌 쿼리입니다.
	SafeMoveUpdatedComponent(DesiredDelta, UpdatedComponent->GetComponentQuat(), true, Hit);

	if (!Hit.IsValidBlockingHit())
	{
		return;
	}

	if (Hit.Normal.Z >= WalkableFloorZ && VerticalVelocity <= 0.f)
	{
		// 충돌한 면이 걸을 수 있는 바닥이면 새로운 바닥으로 저장합니다.
		bIsGrounded = true;
		GroundNormal = Hit.Normal;
		GroundZ = Hit.ImpactPoint.Z + CachedCapsule->GetScaledCapsuleHalfHeight();
		VerticalVelocity = 0.f;
		GroundActor = Hit.GetActor();
		if (GroundActor)
		{
			LastGroundActorLocation = GroundActor->GetActorLocation();
		}
	}
	else
	{
		// 벽이나 너무 가파른 경사면에 부딪힌 경우입니다.
		// 이때는 바닥으로 보지 않아서 중력/낙하가 유지됩니다.
		bIsGrounded = false;
		GroundNormal = FVector::UpVector;
		GroundActor = nullptr;
	}

	// 벽에 딱 붙어서 멈추지 않고, 충돌한 표면을 따라 미끄러지도록 합니다.
	// 원리:
	// - 원래 이동 방향에서 벽 Normal 방향으로 들어가는 성분을 제거한다.
	// - 남은 이동량으로 벽면을 따라 이동한다.
	// Unreal의 MovementComponent가 제공하는 기본 슬라이딩 처리입니다.
	SlideAlongSurface(DesiredDelta, 1.f - Hit.Time, Hit.Normal, Hit, true);
}

void USpartaMoveComponent::ApplyGroundActorMovement()
{
	if (!bIsGrounded || !GroundActor || !UpdatedComponent)
	{
		return;
	}

	const FVector CurrentGroundActorLocation = GroundActor->GetActorLocation();
	const FVector GroundDelta = CurrentGroundActorLocation - LastGroundActorLocation;
	LastGroundActorLocation = CurrentGroundActorLocation;

	if (GroundDelta.IsNearlyZero())
	{
		return;
	}

	FHitResult Hit;
	// 플레이어 입력 이동 전에, 발판이 움직인 거리만큼 Pawn을 먼저 이동시킵니다.
	// 이 처리가 없으면 위아래로 움직이는 플랫폼이 Pawn 밑에서 빠져나가게 됩니다.
	// 즉, "발판 위에 서 있으면 발판의 월드 이동량을 Pawn에게도 적용한다"는 뜻입니다.
	SafeMoveUpdatedComponent(GroundDelta, UpdatedComponent->GetComponentQuat(), true, Hit);
}

SpartaAircraft.h

#pragma once

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

class UCameraComponent;
class USpringArmComponent;
class UStaticMeshComponent;
struct FInputActionValue;

UCLASS()
class SPARTA3_4_API ASpartaAircraft : public APawn
{
	GENERATED_BODY()

public:
	// 6자유도 비행체 Pawn입니다.
	// 현재 회전 상태를 기준으로 전/후, 좌/우, 상/하 이동하고 Yaw/Pitch/Roll을 직접 계산합니다.
	ASpartaAircraft();

	// 비행체의 시각/충돌 루트 컴포넌트입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Components")
	UStaticMeshComponent* Mesh;

	// 카메라를 비행체 뒤에 배치하기 위한 SpringArm입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Components")
	USpringArmComponent* SpringArm;

	// 실제 플레이어 시야 카메라입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Components")
	UCameraComponent* Camera;

	// 지상 또는 일반 비행 상태에서의 기본 이동 속도입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Move")
	float MoveSpeed = 800.f;

	// 공중 상태에서 입력 이동 속도에 곱해지는 값입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Move")
	float AirControlMultiplier = 0.4f;

	// 마우스 X/Y로 적용되는 Yaw/Pitch 회전 속도입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rotation")
	float LookSpeed = 90.f;

	// Roll 입력에 적용되는 회전 속도입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rotation")
	float RollSpeed = 120.f;

	// 공중에서 매 프레임 적용할 인공 중력입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gravity")
	float Gravity = 980.f;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gravity")
	bool bEnableArtificialGravity = false;

	// 아래 방향 지면 체크 거리입니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gravity")
	float GroundCheckDistance = 120.f;

	// 이 값 이상이면 착지 가능한 지면으로 판단합니다.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Gravity")
	float WalkableFloorZ = 0.6f;

protected:
	virtual void BeginPlay() override;
	virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;

public:
	virtual void Tick(float DeltaTime) override;

private:
	// MoveInput.X: 좌우, MoveInput.Y: 전후 입력입니다.
	FVector2D MoveInput = FVector2D::ZeroVector;
	// LookInput.X: Yaw, LookInput.Y: Pitch 입력입니다.
	FVector2D LookInput = FVector2D::ZeroVector;
	// 상하 이동 입력입니다. Space는 +1, Shift는 -1로 사용합니다.
	float VerticalInput = 0.f;
	// Roll 입력입니다. 마우스 휠 또는 별도 키 Axis 값으로 사용합니다.
	float RollInput = 0.f;
	// 인공 중력으로 누적되는 월드 Z축 속도입니다.
	float FallingVelocity = 0.f;
	bool bIsGrounded = false;

	void Move(const FInputActionValue& Value);
	void Look(const FInputActionValue& Value);
	void StartMoveUp(const FInputActionValue& Value);
	void StopMoveUp(const FInputActionValue& Value);
	void StartMoveDown(const FInputActionValue& Value);
	void StopMoveDown(const FInputActionValue& Value);

	void CheckGround();
	void ApplyMovement(float DeltaTime);
	void ApplyRotation(float DeltaTime);
};

SpartaAircraft.cpp

#include "SpartaAircraft.h"

#include "EnhancedInputComponent.h"
#include "SpartaPlayerContrller.h"
#include "Camera/CameraComponent.h"
#include "Components/StaticMeshComponent.h"
#include "GameFramework/SpringArmComponent.h"

ASpartaAircraft::ASpartaAircraft()
{
	PrimaryActorTick.bCanEverTick = true;

	// StaticMesh를 루트로 사용해서 Sweep 충돌 검사를 받을 수 있게 합니다.
	Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("AircraftMesh"));
	SetRootComponent(Mesh);
	Mesh->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
	Mesh->SetCollisionResponseToAllChannels(ECR_Block);
	Mesh->SetSimulatePhysics(false);

	// 비행체 뒤쪽 카메라입니다. 비행체가 회전하면 카메라도 함께 따라갑니다.
	SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
	SpringArm->SetupAttachment(Mesh);
	SpringArm->TargetArmLength = 600.f;
	SpringArm->bUsePawnControlRotation = false;
	SpringArm->bDoCollisionTest = false;

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

void ASpartaAircraft::BeginPlay()
{
	Super::BeginPlay();
}

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

	if (bEnableArtificialGravity)
	{
		CheckGround();
	}
	ApplyRotation(DeltaTime);
	ApplyMovement(DeltaTime);
}

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

	if (UEnhancedInputComponent* EnhancedInput = Cast<UEnhancedInputComponent>(PlayerInputComponent))
	{
		if (ASpartaPlayerContrller* PlayerController = Cast<ASpartaPlayerContrller>(GetController()))
		{
			// MoveAction(Vector2D): W/S는 전후, A/D는 좌우 이동입니다.
			EnhancedInput->BindAction(PlayerController->MoveAction, ETriggerEvent::Triggered, this, &ASpartaAircraft::Move);
			EnhancedInput->BindAction(PlayerController->MoveAction, ETriggerEvent::Completed, this, &ASpartaAircraft::Move);

			// LookAction(Vector2D): 마우스 X는 Yaw, 마우스 Y는 Pitch 회전입니다.
			EnhancedInput->BindAction(PlayerController->LookAction, ETriggerEvent::Triggered, this, &ASpartaAircraft::Look);
			EnhancedInput->BindAction(PlayerController->LookAction, ETriggerEvent::Completed, this, &ASpartaAircraft::Look);

			// JumpAction: Space 입력을 위쪽 이동으로 사용합니다.
			EnhancedInput->BindAction(PlayerController->JumpAction, ETriggerEvent::Triggered, this, &ASpartaAircraft::StartMoveUp);
			EnhancedInput->BindAction(PlayerController->JumpAction, ETriggerEvent::Completed, this, &ASpartaAircraft::StopMoveUp);

			// SprintAction: Shift 입력을 아래쪽 이동으로 사용합니다.
			EnhancedInput->BindAction(PlayerController->SprintAction, ETriggerEvent::Triggered, this, &ASpartaAircraft::StartMoveDown);
			EnhancedInput->BindAction(PlayerController->SprintAction, ETriggerEvent::Completed, this, &ASpartaAircraft::StopMoveDown);
		}
	}
}

void ASpartaAircraft::Move(const FInputActionValue& Value)
{
	MoveInput = Value.Get<FVector2D>();
}

void ASpartaAircraft::Look(const FInputActionValue& Value)
{
	LookInput = Value.Get<FVector2D>();
}

void ASpartaAircraft::StartMoveUp(const FInputActionValue& Value)
{
	if (Value.Get<bool>())
	{
		VerticalInput = 1.f;
		bEnableArtificialGravity = false;
	}
}

void ASpartaAircraft::StopMoveUp(const FInputActionValue& Value)
{
	if (VerticalInput > 0.f)
	{
		VerticalInput = 0.f;
	}
}

void ASpartaAircraft::StartMoveDown(const FInputActionValue& Value)
{
	if (Value.Get<bool>())
	{
		VerticalInput = -1.f;
		bEnableArtificialGravity = true;
	}
}

void ASpartaAircraft::StopMoveDown(const FInputActionValue& Value)
{
	if (VerticalInput < 0.f)
	{
		VerticalInput = 0.f;
	}
}

void ASpartaAircraft::CheckGround()
{
	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	const FVector Start = GetActorLocation();
	const FVector End = Start - FVector(0.f, 0.f, GroundCheckDistance);

	FHitResult Hit;
	FCollisionQueryParams Params(SCENE_QUERY_STAT(AircraftGroundCheck), false, this);

	const bool bHit = World->LineTraceSingleByChannel(
		Hit,
		Start,
		End,
		ECC_Visibility,
		Params
	);

	bIsGrounded = bHit && Hit.Normal.Z >= WalkableFloorZ && FallingVelocity <= 0.f;

	if (bIsGrounded)
	{
		// 착지한 순간 낙하 속도를 초기화합니다.
		FallingVelocity = 0.f;
	}
}

void ASpartaAircraft::ApplyMovement(float DeltaTime)
{
	const float ControlMultiplier = !bIsGrounded
		? AirControlMultiplier
		: 1.f;
	const float CurrentMoveSpeed = MoveSpeed * ControlMultiplier;

	// 현재 Actor 회전 기준의 로컬 축으로 이동합니다.
	FVector WorldMoveDelta = GetActorForwardVector() * MoveInput.Y;
	WorldMoveDelta += GetActorRightVector() * MoveInput.X;
	WorldMoveDelta += GetActorUpVector() * VerticalInput;
	WorldMoveDelta = WorldMoveDelta.GetClampedToMaxSize(1.f) * CurrentMoveSpeed * DeltaTime;

	if (bEnableArtificialGravity && !bIsGrounded)
	{
		// 인공 중력은 월드 아래 방향으로 적용합니다.
		FallingVelocity -= Gravity * DeltaTime;
	}

	if (bEnableArtificialGravity)
	{
		WorldMoveDelta.Z += FallingVelocity * DeltaTime;
	}

	if (WorldMoveDelta.IsNearlyZero())
	{
		return;
	}

	FHitResult Hit;
	AddActorWorldOffset(WorldMoveDelta, true, &Hit);

	if (Hit.IsValidBlockingHit())
	{
		if (bEnableArtificialGravity && Hit.Normal.Z >= WalkableFloorZ && FallingVelocity <= 0.f)
		{
			bIsGrounded = true;
			FallingVelocity = 0.f;
			return;
		}

		// 벽이나 가파른 면에 닿으면 표면을 따라 미끄러지게 이동합니다.
		const FVector RemainingDelta = WorldMoveDelta * (1.f - Hit.Time);
		const FVector SlideDelta = FVector::VectorPlaneProject(RemainingDelta, Hit.Normal);
		AddActorWorldOffset(SlideDelta, true);
	}
}

void ASpartaAircraft::ApplyRotation(float DeltaTime)
{
	if (LookInput.IsNearlyZero() && FMath::IsNearlyZero(RollInput))
	{
		return;
	}

	// 6DOF 회전은 현재 비행체 로컬 축을 기준으로 누적됩니다.
	const float PitchDelta = -LookInput.Y * LookSpeed * DeltaTime;
	const float YawDelta = LookInput.X * LookSpeed * DeltaTime;
	const float RollDelta = RollInput * RollSpeed * DeltaTime;

	AddActorLocalRotation(FRotator(PitchDelta, YawDelta, RollDelta), true);
}

동적할당

코드망령 — Mon, 8 Jun 2026 09:50:45 +0900

동적 할당 (Dynamic Allocation)

동적 할당이란?

프로그램 실행 중에 필요한 메모리를 직접 할당하는 것을 의미한다.

동적으로 할당된 메모리는 힙(Heap) 영역에 저장되며,
개발자가 직접 생성하고 해제해야 한다.

메모리 할당

int* p = new int;
*p = 10;

동작 순서

힙 영역에 int 크기의 메모리 할당
할당된 주소를 p에 저장
해당 메모리에 10 저장

메모리 해제

delete p;
p = nullptr;

동작 순서

힙 메모리 반환
포인터는 더 이상 유효하지 않음
nullptr로 초기화하는 것이 안전함

배열 동적 할당

int* arr = new int[5];

위 코드는 int 5개를 저장할 수 있는 배열을 힙에 생성한다.

배열 메모리 해제

delete[] arr;
arr = nullptr;

배열은 반드시 delete[]를 사용해야 한다.

delete arr; // 잘못된 사용

C 방식 동적 할당

메모리 할당

int* p = (int*)malloc(sizeof(int));
*p = 10;

메모리 해제

free(p);

new 와 malloc 차이

new

int* p = new int;

특징

메모리 할당
생성자 호출
타입 캐스팅 불필요

malloc

int* p = (int*)malloc(sizeof(int));

특징

단순 메모리만 할당
생성자 호출 안 함
형변환 필요

delete 와 free 차이

delete

delete p;

특징

소멸자 호출
메모리 해제

free

free(p);

특징

메모리만 해제
소멸자 호출 안 함

절대 혼용하면 안 됨

올바른 사용

int* p = new int;
delete p;

int* p = (int*)malloc(sizeof(int));
free(p);

잘못된 사용

int* p = new int;
free(p); // 위험

int* p = (int*)malloc(sizeof(int));
delete p; // 위험

동적 할당의 특징

장점

실행 중 크기 결정 가능
큰 메모리 사용 가능
프로그램 유연성 증가

int size;
cin >> size;

int* arr = new int[size];

단점

직접 해제해야 함
메모리 누수 발생 가능
관리가 어려움

메모리 누수 (Memory Leak)

동적으로 할당한 메모리를 해제하지 않으면 발생한다.

void Func()
{
    int* p = new int;

} // delete 없음

위 코드는 함수가 끝나도 힙 메모리가 반환되지 않는다.

이를 메모리 누수라고 한다.

Dangling Pointer (댕글링 포인터)

해제된 메모리를 계속 가리키는 포인터

int* p = new int;

delete p;

*p = 10; // 위험

해결 방법

delete p;
p = nullptr;

객체 동적 생성

class Player
{
public:
    Player()
    {
        cout << "생성자 호출\n";
    }

    ~Player()
    {
        cout << "소멸자 호출\n";
    }
};

Player* p = new Player();

delete p;

실행 결과

생성자 호출
소멸자 호출

스마트 포인터 등장 이유

기존 방식

Player* p = new Player();

// delete를 깜빡할 수 있음

현대 C++

std::shared_ptr<Player> p = std::make_shared<Player>();

std::unique_ptr<Player> p = std::make_unique<Player>();

메모리를 자동으로 관리해준다.

메모리 영역과의 관계

메모리 구조

┌─────────────┐
│ 코드 영역    │
├─────────────┤
│ 데이터 영역  │
├─────────────┤
│ 스택 영역    │ ← 지역 변수
├─────────────┤
│ 힙 영역      │ ← 동적 할당
└─────────────┘

예시

int a = 10;            // 스택
int* p = new int(20);  // 힙

핵심 정리

메모리 할당

int* p = new int;

메모리 해제

delete p;

배열 할당

int* arr = new int[5];

배열 해제

delete[] arr;

C 방식

malloc()
free()

C++ 방식

new
delete

한 줄 요약

동적 할당은 프로그램 실행 중 힙(Heap) 메모리를 직접 생성하고 관리하는 방식이며, 생성한 메모리는 반드시 직접 해제해야 한다.

const

코드망령 — Mon, 8 Jun 2026 09:49:20 +0900

const 정리

1. const 기본 개념

const는 값을 변경할 수 없게 만드는 키워드이다.

const int a = 10;

a = 20; // 오류

읽기 전용 변수(상수)
선언 후 값 변경 불가능

2. const를 사용하는 이유

값 변경 방지

실수로 데이터를 수정하는 것을 막을 수 있다.

코드 의도 명확화

해당 값이 변경되면 안 된다는 것을 명확하게 표현할 수 있다.

최적화 가능

컴파일러가 추가 최적화를 수행할 수 있다.

3. 포인터에서 const

(1) 값이 const

const int* p = &a;

또는

int const* p = &a;

의미

포인터가 가리키는 값 변경 불가
포인터 주소 변경 가능

*p = 20; // 오류
p = &b;  // 가능

(2) 포인터 자체가 const

int* const p = &a;

의미

포인터 주소 변경 불가
가리키는 값 변경 가능

*p = 20; // 가능
p = &b;  // 오류

(3) 둘 다 const

const int* const p = &a;

의미

가리키는 값 변경 불가
포인터 주소 변경 불가

*p = 20; // 오류
p = &b;  // 오류

4. 함수에서 const

(1) 값 전달

void func(const int x);

의미

함수 내부에서 x 변경 불가
복사본을 받기 때문에 큰 의미는 없음

void func(const int x)
{
    x = 10; // 오류
}

(2) 참조 전달 (중요)

void func(const int& x);

의미

복사 발생하지 않음
원본 수정 불가
성능 향상
안전성 향상

void func(const int& x)
{
    // x = 10; // 오류
}

실무에서 가장 많이 사용하는 형태 중 하나이다.

객체 참조 전달

void PrintPlayer(const Player& player);

의미

객체 복사 없음
원본 수정 불가

큰 객체를 함수에 전달할 때 자주 사용한다.

5. 클래스에서 const 함수

class A
{
public:
    int Get() const;
};

의미

멤버 변수 수정 불가
const 객체에서도 호출 가능

class A
{
public:
    int Value = 10;

    int Get() const
    {
        return Value;
    }
};

const 객체

const A Obj;

const 객체는 const 함수만 호출 가능하다.

Obj.Get(); // 가능

Obj.Set(); // 오류

this 포인터 변화

일반 함수

A* const this

const 함수

const A* const this

즉, const 함수 내부에서는 객체를 수정할 수 없다.

6. const vs #define

#define

#define SIZE 10

특징

전처리기 치환
타입 없음
디버깅 어려움

const

const int Size = 10;

특징

타입 존재
컴파일러가 타입 검사 가능
디버깅 쉬움
더 안전함

비교

구분	#define	const
타입	없음	있음
디버깅	어려움	쉬움
타입 검사	불가능	가능
안전성	낮음	높음
사용 권장	❌	✅

7. const와 constexpr 차이

const

실행 중에도 값이 결정될 수 있다.

const int x = GetValue();

constexpr

컴파일 시간에 값이 확정되어야 한다.

constexpr int x = 10;

constexpr int Size = 100;
int Arr[Size];

컴파일 타임 상수로 사용할 수 있다.

8. 실무에서 자주 보는 형태

문자열 전달

void Print(const std::string& Str);

객체 전달

void Update(const Player& PlayerData);

Getter

int GetHP() const;

읽기 전용 포인터

const Player* Target;

9. const 읽는 방법

const int* p;

→ "p가 가리키는 int는 const"

int* const p;

→ "p 자체가 const"

const int* const p;

→ "가리키는 값도 const, 포인터도 const"

핵심 요약

const는 값을 변경할 수 없게 만드는 키워드이다.

특히 중요한 형태

const int&

const std::string&

const Player&

const int*

int* const

const int* const

int GetHP() const;

실무에서는 "수정할 필요가 없는 값은 최대한 const를 붙이는 것" 이 일반적인 코딩 스타일이다.

값 타입과 참조타입

코드망령 — Mon, 8 Jun 2026 09:47:35 +0900

값 타입(Value Type)과 참조 타입(Reference Type)

데이터를 다루는 방식은 크게 값을 직접 저장하는 방식과 어딘가에 있는 데이터를 참조하는 방식으로 나눌 수 있다.

값 타입 (Value Type)

데이터 자체를 직접 저장하는 타입이다.

변수를 복사하면 데이터도 함께 복사된다.

예시

int a = 10;
int b = a;

메모리

a = 10
b = 10

b는 a의 값을 복사하여 별도의 데이터를 가진다.

값 변경

int a = 10;
int b = a;

b = 100;

결과

a = 10
b = 100

원본은 변경되지 않는다.

메모리 구조

┌──────┐
│ a=10 │
└──────┘

┌──────┐
│ b=10 │
└──────┘

서로 다른 메모리를 가진다.

대표적인 값 타입

char
short
int
long
long long
float
double
bool

또한 포인터가 없는 일반 구조체도 값 타입처럼 동작한다.

struct Player
{
    int HP;
};

값 전달 (Call by Value)

void Func(int x)
{
    x = 100;
}

int main()
{
    int num = 10;

    Func(num);

    std::cout << num;
}

결과

값이 복사되었기 때문에 원본은 변경되지 않는다.

참조 타입 (Reference Type)

데이터 자체를 저장하는 것이 아니라 데이터의 위치를 참조하는 타입이다.

참조 변수

int value = 10;

int& ref = value;

메모리 구조

ref ───► value
          │
          ▼
         10

ref는 value의 별명(Alias)이다.

값 변경

int value = 10;

int& ref = value;

ref = 100;

결과

value = 100

원본이 변경된다.

참조 전달 (Call by Reference)

void Func(int& x)
{
    x = 100;
}

사용

int num = 10;

Func(num);

결과

원본 데이터가 변경된다.

포인터도 참조 개념을 사용한다

int value = 10;

int* ptr = &value;

메모리 구조

ptr ───► value
          │
          ▼
         10

값 변경

*ptr = 100;

결과

value = 100

원본 데이터가 변경된다.

값 타입과 참조 타입 비교

항목	값 타입	참조 타입
저장 내용	데이터 자체	데이터의 위치
복사 시	값 복사	같은 데이터 참조
원본 변경	불가능	가능
메모리 사용	별도 메모리	같은 메모리 공유
대표 예시	int, float, double	참조자(&), 포인터(*)

값 캡처와 참조 캡처 (람다)

값 캡처

int x = 10;

auto lambda = [x]()
{
    std::cout << x;
};

람다가 생성될 때 값이 복사된다.

x = 100;

해도

lambda();

결과

참조 캡처

int x = 10;

auto lambda = [&x]()
{
    x = 100;
};

실행 후

x = 100

원본이 변경된다.

얕은 복사와의 차이

값 타입과 참조 타입은 얕은 복사(Shallow Copy)와는 다른 개념이다.

값 복사

int a = 10;
int b = a;

a = 10
b = 10

서로 독립적이다.

얕은 복사

class Player
{
public:
    int* HP;
};

Player p2 = p1;

p1.HP ----+
          |
          v
        [100]
          ^
          |
p2.HP ----+

같은 메모리를 가리킨다.

정리

값 타입은 데이터를 직접 저장한다.
값을 복사하면 별도의 데이터가 생성된다.
참조 타입은 데이터의 위치를 참조한다.
참조 타입은 원본 데이터를 수정할 수 있다.
참조자(&)와 포인터(*)는 참조 개념을 사용한다.
값 전달(Call by Value)은 원본이 변경되지 않는다.
참조 전달(Call by Reference)은 원본이 변경된다.
람다의 [x]는 값 캡처, [&x]는 참조 캡처이다.
값 타입/참조 타입과 얕은 복사/깊은 복사는 서로 다른 개념이다.

extern (외부 변수)

코드망령 — Fri, 5 Jun 2026 09:33:54 +0900

extern (외부 변수)

현재 파일이 아닌 다른 파일에 존재하는 변수나 함수를 참조하기 위한 키워드

외부 변수란?

현재 파일의 코드 외에

다른 파일에 존재하는 변수를 의미한다.

예)

// A.cpp

int a = 10;

// B.cpp

extern int a;

B.cpp에서는 실제 변수는 없지만

extern을 통해

"어딘가에 존재하는 변수 a를 사용하겠다"

라고 컴파일러에게 알려주는 것이다.

사용 예제

변수 정의

// A.cpp

int a = 10;

변수 참조

// B.cpp

extern int a;

void Func()
{
    a = 20;
}

문법적으로 아무 문제가 없다.

extern의 동작 방식

컴파일 단계

extern int a;

컴파일러는

"어딘가에 int형 변수 a가 존재한다고 가정"

하고 코드를 컴파일한다.

따라서 실제 변수의 존재 여부를 검사하지 않는다.

즉,

extern int a;

만 있어도 컴파일은 성공한다.

링크 단계

컴파일이 끝나면 링커(Linker)가

실제로 변수 a가 존재하는지 확인한다.

예)

// A.cpp

int a = 10;

존재한다면

extern int a;

와 연결하여 정상적으로 실행된다.

링크 오류 발생 예제

// B.cpp

extern int a;

void Func()
{
    a = 20;
}

그런데

// A.cpp

// int a = 10;

처럼 실제 변수가 존재하지 않는다면

컴파일은 성공하지만

링크 단계에서

unresolved external symbol

오류가 발생한다.

왜 컴파일은 성공할까?

컴파일러는 현재 파일만 본다.

extern int a;

를 보면

"다른 파일에 정의되어 있겠지"

라고 생각하고 넘어간다.

실제 존재 여부는 컴파일러가 아니라

링커가 검사한다.

extern 변수의 메모리

extern int a;

는 새로운 변수를 생성하지 않는다.

즉,

extern int a;

는

int a;

와 다르다.

변수 생성

int a = 10;

메모리 생성
저장 공간 할당

extern 선언

extern int a;

메모리 생성 안 함
저장 공간 할당 안 함
이미 존재하는 변수를 참조

extern 함수

함수도 동일하게 사용할 수 있다.

// A.cpp

void Print()
{
}

// B.cpp

extern void Print();

int main()
{
    Print();
}

다만 함수는 기본적으로 외부 연결(External Linkage)을 가지므로

대부분의 경우 extern을 생략해도 된다.

void Print();

와 동일하게 동작한다.

정리

extern은

다른 파일에 존재하는 변수나 함수를 참조하기 위한 키워드이다.

extern int a;

새로운 변수를 생성하지 않음
메모리를 할당하지 않음
다른 파일의 변수를 참조만 함

컴파일 단계에서는

extern int a;

만 있어도 통과한다.

하지만 링크 단계에서 실제 변수 정의를 찾지 못하면

unresolved external symbol

오류가 발생한다.

즉,

컴파일러 → 문법 검사
링커 → 실제 정의 연결

을 수행한다고 이해하면 된다.

분할 구조 (Header / Source File)

코드망령 — Fri, 5 Jun 2026 09:31:13 +0900

분할 구조 (Header / Source File)

하나의 코드를 .h 파일과 .cpp 파일로 나누어 관리하는 방식

일반적으로

.h : 선언(Declaration)
.cpp : 구현(Definition)

을 담당한다.

장점

코드 관리가 편해짐

기능별로 파일을 분리할 수 있다.

예)

Player.h
Player.cpp

Monster.h
Monster.cpp

Inventory.h
Inventory.cpp

파일 역할이 명확해져 유지보수가 쉬워진다.

협업 시 충돌 감소

여러 사람이 동시에 작업할 때
각자 다른 파일을 수정할 수 있다.

예)

A : Player.cpp 수정
B : Inventory.cpp 수정

Git 충돌이 줄어든다.

재사용 가능

헤더만 include 하면
다른 코드에서도 쉽게 사용할 수 있다.

예)

#include "Player.h"

컴파일 속도 개선 가능

변경된 cpp 파일만 다시 컴파일하면 된다.

예)

Player.cpp 수정

↓

Player.cpp만 재컴파일

큰 프로젝트일수록 효과가 커진다.

단점

파일 수 증가

기능 하나를 만들더라도

Player.h
Player.cpp

처럼 최소 두 개의 파일이 필요하다.

프로젝트 규모가 커질수록 파일 관리가 복잡해질 수 있다.

include 남용 시 컴파일 속도 저하

헤더를 include하면
전처리 단계에서 해당 파일 내용이 복사된다.

예)

#include "A.h"
#include "B.h"
#include "C.h"

↓

컴파일 시

A.h 내용
B.h 내용
C.h 내용

이 전부 복사되어 하나의 파일처럼 처리된다.

따라서 불필요하게 많은 헤더를 include하면
컴파일 속도가 느려질 수 있다.

순환 참조(Circular Dependency) 문제

예)

Player.h
#include "Monster.h"

Monster.h
#include "Player.h"

서로를 include하게 되면
컴파일러가 타입을 완성할 수 없어 오류가 발생한다.

해결 방법

전방 선언(Forward Declaration)을 사용한다.

class Monster;

class Player
{
private:
    Monster* Target;
};

필요한 경우에만 cpp에서 include한다.

중복 정의 문제

헤더에서 함수를 구현하면

// MyClass.h

void Func()
{
}

해당 헤더를 여러 cpp가 include했을 때

A.cpp
#include "MyClass.h"

B.cpp
#include "MyClass.h"

함수가 여러 번 정의되어

Multiple Definition

오류가 발생할 수 있다.

해결 방법

헤더에는 선언만 작성한다.

// MyClass.h

void Func();

// MyClass.cpp

void Func()
{
}

디버깅이 불편할 수 있음

선언과 구현이 분리되어 있기 때문에

Player.h

↓

Player.cpp

를 계속 오가며 확인해야 한다.

작은 프로젝트에서는 오히려 불편할 수 있다.

캡슐화가 깨질 위험

헤더에 너무 많은 내용을 공개하면

외부 코드가 내부 구현에 의존하게 될 수 있다.

예)

class Player
{
public:
    int HP;
    int MP;
    int Level;
};

외부에서 직접 접근 가능

player.HP = -9999;

해결 방법

필요한 정보만 공개한다.

class Player
{
private:
    int HP;

public:
    int GetHP() const;
};

정리

분할 구조는

코드 관리
협업
재사용성

측면에서 매우 큰 장점이 있다.

하지만

include 남용
순환 참조
중복 정의

문제를 유발할 수 있으므로

전방 선언 사용
필요한 헤더만 include
선언과 구현 분리

를 지켜서 사용하는 것이 중요하다.

nullptr

코드망령 — Fri, 5 Jun 2026 09:30:06 +0900

nullptr

포인터 전용 null 값

NULL의 문제점

void func(int x);
void func(int* x);

func(NULL);

NULL은 일반적으로 다음과 같이 정의되어 있다.

#define NULL 0

즉, NULL은 결국 정수 0이다.

따라서

void func(int);
void func(int*);

두 함수 모두 호출 후보가 된다.

0 → int 변환 가능
0 → int* 변환 가능

컴파일러는 어떤 함수를 호출해야 하는지 결정할 수 없기 때문에 모호성(Ambiguity) 오류가 발생한다.

nullptr 사용

void func(int x);
void func(int* x);

func(nullptr);

nullptr은 std::nullptr_t 타입을 가지는 특수한 값이다.

포인터 타입으로만 변환 가능
정수 타입으로는 변환되지 않음

따라서

func(int*);

만 호출 후보가 된다.

결과적으로 컴파일러는 명확하게 func(int*)를 선택할 수 있으며 모호성 오류가 발생하지 않는다.

nullptr의 특징

int* ptr = nullptr;

nullptr은

유효한 메모리를 가리키지 않는 상태를 표현하는 값
포인터 전용 null 값
std::nullptr_t 타입을 가지는 특수한 리터럴

이다.

NULL vs nullptr

구분	NULL	nullptr
타입	정수(0)	std::nullptr_t
정수 변환	가능	불가능
포인터 변환	가능	가능
함수 오버로딩 모호성	발생 가능	발생하지 않음
C++ 권장 여부	비권장	권장

권장 방식

현대 C++에서는 NULL 대신 nullptr 사용을 권장한다.

int* ptr = nullptr;

if (ptr == nullptr)
{
    // 포인터가 아무것도 가리키지 않음
}

포인터가 유효한 객체를 가리키지 않는다는 의미를 명확하게 표현할 수 있으며, 함수 오버로딩에서 발생할 수 있는 모호성 문제도 방지할 수 있다.

언리얼 C++과제3

코드망령 — Thu, 4 Jun 2026 21:25:52 +0900

스파르타 클럽 챕터3 과제3 진행 (1/2)

회전발판과 움직이는 장애물을 만드는 과제입니다.

현재 발판의 회전과 움직이는 장애물을 구현했습니다.

https://youtu.be/lf_np--qstI?si=o1tioc16b0MkbILz

액터는 MovingActor와 RotateActor클래스를 따로 만들어서 BP로 상속받아서

현재는 맵에 직접 넣는 방식으로 구현했습니다.

MovingActor.h

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

#pragma once

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

UCLASS()
class SPARTA3_4_API AMovingActor : public AActor
{
    GENERATED_BODY()

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

    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Mesh")
    UStaticMeshComponent* MC;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
    float Distance = 500.f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
    float Speed = 400.f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
    float TimerInterval = 0.01f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movement")
    bool bMoveVertical = false;

    UFUNCTION(BlueprintCallable, Category = "Movement")
    void StartMove();
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

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

private:
    FTimerHandle MoveTimer;
    FTimerHandle ReturnTimer;

    FVector StartLocation;
    FVector EndLocation;

    bool bIsReturning = false;

    UFUNCTION()
    void MoveForward();
    UFUNCTION()
    void ReturnStartLocation();
};

MovingActor.cpp

#include "MovingActor.h"
#include "Components/StaticMeshComponent.h"
#include "TimerManager.h"

// Sets default values
AMovingActor::AMovingActor()
{
     // 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;

    MC = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StaticMesh"));
    RootComponent = MC;
}

void AMovingActor::StartMove()
{
    StartLocation = GetActorLocation();
    const FVector MoveDirection = bMoveVertical ? FVector::UpVector : GetActorForwardVector();
    EndLocation = StartLocation + MoveDirection * Distance;

    GetWorldTimerManager().ClearTimer(MoveTimer);
    GetWorldTimerManager().ClearTimer(ReturnTimer);

    GetWorldTimerManager().SetTimer(
        MoveTimer,
        this,
        &AMovingActor::MoveForward,
        TimerInterval,
        true
    );
}

void AMovingActor::BeginPlay()
{
    Super::BeginPlay();
}

void AMovingActor::MoveForward()
{
    const FVector CurrentLocation = GetActorLocation();
    const FVector ToTarget = EndLocation - CurrentLocation;
    const float DistanceToTarget = ToTarget.Size();
    const float Step = Speed * TimerInterval;

    if (DistanceToTarget <= Step)
    {
        SetActorLocation(EndLocation);

        GetWorldTimerManager().ClearTimer(MoveTimer);
        GetWorldTimerManager().SetTimer(
            ReturnTimer,
            this,
            &AMovingActor::ReturnStartLocation,
            TimerInterval,
            true
            );

        return;
    }

    SetActorLocation(CurrentLocation + ToTarget.GetSafeNormal() * Step);
}

void AMovingActor::ReturnStartLocation()
{
    const FVector CurrentLocation = GetActorLocation();
    const FVector ToTarget = StartLocation - CurrentLocation;
    const float DistanceToTarget = ToTarget.Size();
    const float Step = Speed * TimerInterval;

    if (DistanceToTarget <= Step)
    {
        SetActorLocation(StartLocation);

        GetWorldTimerManager().ClearTimer(ReturnTimer);
        GetWorldTimerManager().SetTimer(
            MoveTimer,
            this,
            &AMovingActor::MoveForward,
            TimerInterval,
            true
            );
        return;
    }

    SetActorLocation(CurrentLocation + ToTarget.GetSafeNormal() * Step);
}

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

}

RotateActor.h

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

#pragma once

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

UENUM(BlueprintType)
enum class ERotateMode : uint8
{
    KeepRotating UMETA(DisplayName = "Keep Rotating"),
    StopRotating UMETA(DisplayName = "Stop After Time"),
    ReverseRotating UMETA(DisplayName = "Reverse Rotating"),
    StopAndReverseRotating UMETA(DisplayName = "Stop After Time And Reverse"),
};

UENUM(BlueprintType)
enum class ERotateAxis : uint8
{
    Pitch UMETA(DisplayName = "Pitch / Y Axis"),
    Yaw UMETA(DisplayName = "Yaw / Z Axis"),
    Roll UMETA(DisplayName = "Roll / X Axis"),
};

UCLASS()
class SPARTA3_4_API ARotateActor : public AActor
{
    GENERATED_BODY()

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

    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Mesh")
    UStaticMeshComponent* MC;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rotation")
    float RotationSpeed = 90.f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rotation")
    float RotateDuration = 2.f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rotation")
    float TimerInterval = 0.01f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rotation")
    float StopDuration = 1.f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rotation")
    ERotateMode RotateMode = ERotateMode::KeepRotating;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rotation")
    ERotateAxis RotateAxis = ERotateAxis::Yaw;

    UFUNCTION(BlueprintCallable, Category = "Rotation")
    void StartRotating();

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;
public:
    // Called every frame
    virtual void Tick(float DeltaTime) override;

private:
    FTimerHandle RotateTimer;
    FTimerHandle RestartTimer;

    float ElapsedTime = 0.f;
    float RotateDirection = 1.f;

    UFUNCTION()
    void RotateStep();

    UFUNCTION()
    void StopRotate();
    UFUNCTION()
    void ReverseRotate();
};

RotateActor.cpp

#include "RotateActor.h"


// Sets default values
ARotateActor::ARotateActor()
{
    // 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;

    MC = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StaticMesh"));
    RootComponent = MC;
}

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

}

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



void ARotateActor::StartRotating()
{
    ElapsedTime = 0.f;

    GetWorldTimerManager().ClearTimer(RotateTimer);
    GetWorldTimerManager().ClearTimer(RestartTimer);
    GetWorldTimerManager().SetTimer(
        RotateTimer,
        this,
        &ARotateActor::RotateStep,
        TimerInterval,
        true
    );
}

void ARotateActor::RotateStep()
{
    ElapsedTime += TimerInterval;

    const float RotationAmount = RotationSpeed * RotateDirection * TimerInterval;
    FRotator DeltaRotation = FRotator::ZeroRotator;

    switch (RotateAxis)
    {
    case ERotateAxis::Pitch:
        DeltaRotation.Pitch = RotationAmount;
        break;

    case ERotateAxis::Yaw:
        DeltaRotation.Yaw = RotationAmount;
        break;

    case ERotateAxis::Roll:
        DeltaRotation.Roll = RotationAmount;
        break;
    }

    AddActorLocalRotation(DeltaRotation);

    if (RotateMode == ERotateMode::StopRotating && ElapsedTime >= RotateDuration)
    {
        StopRotate();
    }
    else if (RotateMode == ERotateMode::ReverseRotating && ElapsedTime >= RotateDuration)
    {
        StopRotate();
        ElapsedTime = 0.f;

        GetWorldTimerManager().SetTimer(
            RestartTimer,
            this,
            &ARotateActor::StartRotating,
            StopDuration,
            false
        );
    }
    else if (RotateMode == ERotateMode::StopAndReverseRotating && ElapsedTime >= RotateDuration)
    {
        StopRotate();
        ReverseRotate();
        ElapsedTime = 0.f;

        GetWorldTimerManager().SetTimer(
            RestartTimer,
            this,
            &ARotateActor::StartRotating,
            StopDuration,
            false
        );
    }
}

void ARotateActor::StopRotate()
{
    GetWorldTimerManager().ClearTimer(RotateTimer);
}

void ARotateActor::ReverseRotate()
{
    RotateDirection *= -1.f;
}

Timer를 사용하여 0.01초가 지나면 조금씩 이동하도록 설정해서 부드럽게 움직이는 것 처럼 보이게 만들었습니다.

각 파라미터들은 에디터에서 변경 가능하도록 리플렉션 매크로를 EditAnywhere로 설정했습니다.

FOnlineSessionSettings

코드망령 — Wed, 3 Jun 2026 12:42:11 +0900

제가 학습한 것을 기준으로 만들어진 것이기 때문에 이 글 내용이 틀렸을 수도 있습니다.

FOnlineSessionSettings

FOnlineSessionSettings는 세션을 만들 때 OnlineSubsystem에게 넘겨주는 설정값 묶음이다.

직접 방을 생성하는 클래스라기보다는, 어떤 방식의 방을 만들지 설명하는 데이터 객체라고 볼 수 있다.

실제 세션 생성은 CreateSession()에서 이루어지며,
FOnlineSessionSettings에 설정한 값에 따라 세션의 동작이 결정된다.

기본 개념

TSharedPtr<FOnlineSessionSettings> SessionSettings = MakeShareable(new FOnlineSessionSettings());

기본 생성자에서는 대부분의 값이 다음과 같이 초기화된다.

false
0

즉, 대부분의 기능은 기본적으로 꺼져 있으며,
필요한 기능만 개발자가 직접 활성화하는 방식이다.

NumPublicConnections

공개 접속 슬롯 수

다른 플레이어가 일반적으로 참가할 수 있는 자리 수를 의미한다.

SessionSettings->NumPublicConnections = 4;

위 설정은 최대 4명이 참가 가능한 세션을 의미한다.

NumPrivateConnections

비공개 접속 슬롯 수

초대 전용 슬롯이나 예약 슬롯 등에 사용할 수 있다.

SessionSettings->NumPrivateConnections = 2;

모든 OnlineSubsystem에서 적극적으로 사용되는 것은 아니다.

bShouldAdvertise

세션을 검색에 노출할지 여부

SessionSettings->bShouldAdvertise = true;

true

FindSessions() 검색 가능
다른 플레이어가 방을 찾을 수 있음

false

방은 생성되지만 검색 결과에 나타나지 않을 수 있음

bAllowJoinInProgress

게임 진행 중 참가 허용 여부

SessionSettings->bAllowJoinInProgress = true;

true

게임이 시작된 후에도 참가 가능

false

게임 시작 이후 참가 불가

bIsLANMatch

LAN 세션 여부

SessionSettings->bIsLANMatch = true;

true

같은 네트워크 내부에서만 검색 가능

false

Steam, EOS 등의 온라인 서비스 사용

예시

SessionSettings->bIsLANMatch =
    IOnlineSubsystem::Get()->GetSubsystemName() == "NULL";

NULL Subsystem이면 LAN 세션으로 생성

bIsDedicated

전용 서버 여부

SessionSettings->bIsDedicated = true;

true

Dedicated Server

false

Listen Server

일반적인 Host 방식

SessionSettings->bIsDedicated = false;

플레이어가 직접 호스트하는 방식

bUsesStats

온라인 통계 시스템 사용 여부

SessionSettings->bUsesStats = true;

예시

킬 수
승패 기록
점수 기록

실제 지원 여부는 OnlineSubsystem에 따라 다르다.

bAllowInvites

친구 초대 허용 여부

SessionSettings->bAllowInvites = true;

플랫폼이 제공하는 친구 초대 기능을 사용할 수 있다.

bUsesPresence

Presence 사용 여부

SessionSettings->bUsesPresence = true;

Presence란 현재 유저 상태 정보이다.

예시

게임 접속 중
로비 대기 중
특정 세션 참가 중

활용 예시

Steam 친구 목록

친구가 현재 게임 플레이 중

같은 정보 제공

bAllowJoinViaPresence

Presence를 통한 참가 허용 여부

SessionSettings->bAllowJoinViaPresence = true;

예시

친구 목록 → 게임 참가

기능 지원

bAllowJoinViaPresenceFriendsOnly

친구만 Presence 참가 허용

SessionSettings->bAllowJoinViaPresenceFriendsOnly = true;

true

친구만 참가 가능

false

누구나 참가 가능

bAntiCheatProtected

안티치트 보호 세션 여부

SessionSettings->bAntiCheatProtected = true;

예시

VAC
PunkBuster
Easy Anti Cheat

실제 동작은 플랫폼마다 다르다.

bUseLobbiesIfAvailable

Lobby API 사용 여부

SessionSettings->bUseLobbiesIfAvailable = true;

플랫폼이 Lobby 기능을 지원하면

Session API
    ↓
Lobby API 우선 사용

UE5 Steam/EOS 멀티플레이에서 자주 사용된다.

bUseLobbiesVoiceChatIfAvailable

Lobby 음성 채팅 사용 여부

SessionSettings->bUseLobbiesVoiceChatIfAvailable = true;

Lobby 생성 시

음성 채팅방 생성
자동 참가

기능을 활성화한다.

SessionIdOverride

세션 ID 직접 지정

SessionSettings->SessionIdOverride = TEXT("MySession");

보통은 사용하지 않는다.

대부분 플랫폼이 자동 생성한다.

BuildUniqueId

빌드 구분용 ID

SessionSettings->BuildUniqueId = 1;

서로 다른 빌드끼리 세션 검색 결과가 섞이지 않도록 한다.

예시

빌드	ID
개발 빌드	1
테스트 빌드	2
출시 빌드	3

Settings

커스텀 세션 설정 저장소

TMap<FName, FOnlineSessionSetting>

매치 타입, 맵 이름, 게임 모드 등을 저장할 수 있다.

값 저장

SessionSettings->Set(
    FName("MatchType"),
    FString("FreeForAll"),
    EOnlineDataAdvertisementType::ViaOnlineServiceAndPing
);

<br>
#### EOnlineDataAdverisementType

Set으로 저장한 값을 어디에 노출하는지 정하는 옵션이다.

DontAdvertise

세션 안에는 저장하지만, 외부 검색결과나 Qos/ping 데이터로 노출하지 않음.

ViaPingOnly

온라인 서비스의 세션 검색 데이터에는 올리지 않고, 서버에 ping/Qos 질의를 했을 때만 전달되게 함.

ViaOnlineService

Steam, EOS같은 Online Subsystem의 세션 검색 결과에 포함되게 함.

ViaOnlineServiceAndPing

세션 검색 결과에도 나오고, ping/Qos응답에도 포함 될 수 있게 함.
---

## 값 읽기

FString MatchType;

SearchResult.Session.SessionSettings.Get(
FName("MatchType"),
MatchType
);


---

## 활용 예시

MatchType
MapName
GameMode
Difficulty


---

## MemberSettings

세션 전체가 아닌

플레이어 개별 설정 저장소

---

예시

플레이어 A
└ 팀 : Red

플레이어 B
└ 팀 : Blue

플레이어 C
└ 캐릭터 : Warrior


---

활용 가능 정보

-   팀 정보
-   역할 정보
-   선택 캐릭터
-   플레이어 상태

---

모든 OnlineSubsystem이 지원하는 것은 아니다.

---

## 정리

`FOnlineSessionSettings`

-   세션 생성 옵션을 저장하는 데이터 객체
-   직접 세션을 만드는 클래스는 아님
-   `CreateSession()` 호출 시 OnlineSubsystem에 전달됨

주요 설정

NumPublicConnections


공개 접속 슬롯 수

bShouldAdvertise


검색 노출 여부

bAllowJoinInProgress


중간 참가 허용 여부

bIsLANMatch


LAN 세션 여부

bUsesPresence


Presence 사용 여부

bAllowJoinViaPresence


친구 목록을 통한 참가 허용

bUseLobbiesIfAvailable


Lobby API 사용 여부

Settings


매치 타입, 맵 이름 등 커스텀 정보 저장

---

즉, `FOnlineSessionSettings`는

> "어떤 방을 만들 것인가?"

를 OnlineSubsystem에게 설명하는 설정 데이터 묶음이다.

설정을 모두 완료한 뒤

SessionInterface->CreateSession(...)

```

에 전달하면 OnlineSubsystem이 해당 설정을 기반으로 세션을 생성한다.

FInputModeUIOnly

코드망령 — Tue, 2 Jun 2026 17:02:33 +0900

Udemy에서 구매한 강의를 공부하면서 배운 내용입니다.

개인적으로 따로 알고싶어서 공부한 부분들도 있으니 내용에 틀린 것이 있을 수 있습니다.

https://www.udemy.com/course/unreal-engine-5-cpp-multiplayer-shooter/?couponCode=MT260602G3

Unreal Engine 5 C++ Multiplayer Shooter

Over 64 hours of content!Learn all about Unreal Engine multiplayer in this fully comprehensive C++ course. From scratch, we create a complete multiplayer shooter game, capable of creating and joining game sessions and connecting

www.udemy.com

이 강의를 들으며 공부했습니다.

FInputModeUIOnly

플레이어 컨트롤러에 적용하여 입력이 UI에만 전달되도록 설정하는 클래스

주로 메뉴 화면, 옵션 창, 로그인 화면, 로비 UI처럼

캐릭터 조작은 막고
버튼 클릭
텍스트 입력
UI 네비게이션

만 가능하게 만들 때 사용한다.

강의 중 적은 코드

Menu.h

#pragma once

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

UCLASS()
class MULTIPLAYERSESSIONS_API UMenu : public UUserWidget
{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintCallable)
    void MenuSetUp();

private:
    UPROPERTY(meta = (BindWidget))
    class UButton* HostButton;

    UButton* JoinButton;
};

Menu.cpp

void UMenu::MenuSetUp()
{
    AddToViewport();
    SetVisibility(ESlateVisibility::Visible);
    SetIsFocusable(true);

    UWorld* World = GetWorld();

    if (World)
    {
        APlayerController* PlayerController =
            World->GetFirstPlayerController();

        if (PlayerController)
        {
            FInputModeUIOnly InputModeData;

            InputModeData.SetWidgetToFocus(TakeWidget());
            InputModeData.SetLockMouseToViewportBehavior(
                EMouseLockMode::DoNotLock);

            PlayerController->SetInputMode(InputModeData);
            PlayerController->SetShowMouseCursor(true);
        }
    }
}

MenuSetUp 흐름

1. UI를 화면에 표시

AddToViewport();
SetVisibility(ESlateVisibility::Visible);

2. UI가 키보드 입력을 받을 수 있도록 설정

SetIsFocusable(true);

bIsFocusable = true 대신 사용

3. 플레이어 컨트롤러 가져오기

APlayerController* PlayerController =
    World->GetFirstPlayerController();

입력 모드를 변경하기 위해 필요하다.

4. UI 전용 입력 모드 생성

FInputModeUIOnly InputModeData;

UI만 입력을 받을 수 있는 입력 모드

5. 포커스를 줄 위젯 설정

InputModeData.SetWidgetToFocus(TakeWidget());

현재 위젯에 키보드 포커스를 준다.

6. 마우스 잠금 설정

InputModeData.SetLockMouseToViewportBehavior(
    EMouseLockMode::DoNotLock);

마우스를 뷰포트 안에 가둘지 결정한다.

7. 입력 모드 적용

PlayerController->SetInputMode(InputModeData);

플레이어 입력을 UI 전용으로 변경

8. 마우스 커서 표시

PlayerController->SetShowMouseCursor(true);

UI를 조작할 수 있도록 마우스 커서를 표시

SetWidgetToFocus

ENGINE_API FInputModeUIOnly&
SetWidgetToFocus(TSharedPtr<SWidget> InWidgetToFocus);

UI 입력 포커스를 받을 위젯을 설정한다.

사용 예시

InputModeData.SetWidgetToFocus(TakeWidget());

현재 UUserWidget을 포커스 대상으로 설정

반환형이 레퍼런스인 이유

체이닝(Chaining)을 지원하기 위해 자기 자신을 반환한다.

InputModeData
    .SetWidgetToFocus(TakeWidget())
    .SetLockMouseToViewportBehavior(
        EMouseLockMode::DoNotLock);

이처럼 함수를 이어서 호출할 수 있다.

SetLockMouseToViewportBehavior

ENGINE_API FInputModeUIOnly&
SetLockMouseToViewportBehavior(
    EMouseLockMode InMouseLockMode);

마우스를 뷰포트 내부에 가둘지 설정한다.

EMouseLockMode 종류

DoNotLock

EMouseLockMode::DoNotLock

마우스를 가두지 않는다.

게임 창 밖으로 이동 가능

LockAlways

EMouseLockMode::LockAlways

게임이 활성화 상태라면 항상 마우스를 뷰포트 안에 가둔다.

LockInFullscreen

EMouseLockMode::LockInFullscreen

전체 화면 모드일 때만 마우스를 가둔다.

LockOnCapture

EMouseLockMode::LockOnCapture

클릭 또는 드래그 등 입력이 발생했을 때 마우스를 가둔다.

사용 예시

InputModeData.SetLockMouseToViewportBehavior(
    EMouseLockMode::DoNotLock);

마우스가 게임 창 밖으로 이동 가능

TakeWidget()

TakeWidget()

UUserWidget을 Slate 시스템의 SWidget 형태로 변환하여 반환한다.

이유

SetWidgetToFocus()는

TSharedPtr<SWidget>

형태를 요구한다.

하지만 UMG 위젯은

UUserWidget

기반이기 때문에 직접 전달할 수 없다.

따라서

TakeWidget()

을 사용하여 Slate 위젯으로 변환 후 전달한다.

사용 예시

InputModeData.SetWidgetToFocus(TakeWidget());

현재 위젯이 입력 포커스를 받도록 설정한다.

정리

FInputModeUIOnly

UI만 입력 받도록 설정
캐릭터 조작 불가능
메뉴, 옵션, 로그인, 로비 UI에서 사용

주요 함수

SetWidgetToFocus()

입력 포커스를 줄 위젯 지정

SetLockMouseToViewportBehavior()

마우스 잠금 방식 설정

TakeWidget()

UUserWidget → SWidget 변환

PlayerController->SetInputMode(InputModeData);

UI 전용 입력 모드 적용

PlayerController->SetShowMouseCursor(true);

마우스 커서 표시