[2025.01.21] Unreal_7기 | 챕터 3. C++과 Unreal Engine으로 3D 게임 개발

코드카타

문제 설명

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면

array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.
1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.
2에서 나온 배열의 3번째 숫자는 5입니다.
배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한사항
array의 길이는 1 이상 100 이하입니다.
array의 각 원소는 1 이상 100 이하입니다.
commands의 길이는 1 이상 50 이하입니다.
commands의 각 원소는 길이가 3입니다.
입출력 예
array commands return
[1, 5, 2, 6, 3, 7, 4] [[2, 5, 3], [4, 4, 1], [1, 7, 3]] [5, 6, 3]

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> solution(vector<int> array, vector<vector<int>> commands) {
    vector<int> answer;
    vector<int> temp;
    for (vector<int> inner : commands)
    {
        for (int i = inner[0]-1; i <= inner[1]-1; i++)
        {
            temp.push_back(array[i]);
        }
        sort(temp.begin(), temp.end());
        answer.push_back(temp[inner[2]-1]);
        temp.clear();
    }
    return answer;
}

---

발제 7번 Pawn 클래스로 움직임 구현

 

필수 과제 (기본 요구 사항) 

필수 과제 1번 - C++ Pawn 클래스와 충돌 컴포넌트 구성

• Pawn 클래스 생성
  • 충돌 컴포넌트를 루트 컴포넌트로 설정합니다 (CapsuleComponent/BoxComponent/SphereComponent 중 택 1).
  • SkeletalMeshComponent, SpringArmComponent, CameraComponent를 부착하여 3인칭 시점을 구성합니다.
  • GameMode에서 DefaultPawnClass를 이 Pawn 클래스로 지정합니다.
• Physics 설정
  • 루트 충돌 컴포넌트 및 SkeletalMeshComponent 모두 Simulate Physics = false로 설정합니다.
  • 물리 시뮬레이션이 아닌 코드로 직접 제어합니다.

필수 과제 2번 - Enhanced Input 매핑 & 바인딩

• Input 액션 생성
  • Move (WASD용 - Vector2D 타입)
  • Look (마우스 이동용 - Vector2D 타입)
  • Input Mapping Context (IMC)에 액션들을 매핑합니다.
• 입력 바인딩 및 이동/회전 로직 구현
  • SetupPlayerInputComponent()에서 각 액션에 함수를 바인딩합니다.
  • AddActorLocalOffset(), AddActorLocalRotation() 등을 사용하여 이동과 회전을 구현합니다.
  • 이동 방향은 Pawn의 Forward/Right 벡터에 따라 결정됩니다.
  • 마우스 입력으로 Yaw와 Pitch를 직접 계산하여 회전을 구현합니다.
    • AddControllerYawInput() 또는 AddControllerPitchInput() 같은 기본 제공 함수를 사용하지 않습니다.
  • 평면 상에서의 이동 및 회전만 처리합니다 (중력/낙하 효과 없음).

4️⃣도전 과제 (선택 요구 사항) 🦅

도전 과제 1번 - 6자유도 (6 DOF) 드론/비행체 구현 (난이도 상)

• 6축 이동 및 회전 액션 구현
  • 이동
    • 전/후 (W/S) - 로컬 X축 이동
    • 좌/우 (A/D) - 로컬 Y축 이동
    • 상/하 (Space/Shift) - 로컬 Z축 이동
  • 회전
    • Yaw - 좌우 회전, 마우스 X축 이동
    • Pitch - 상하 회전, 마우스 Y축 이동
    • Roll - 기울기 회전, 마우스 휠 또는 별도 키
• Local 기반 이동 구현
  • 현재 Pawn의 회전 상태에 따라 이동 방향이 결정되는 비행체 움직임을 구현합니다.
  • 단순 월드 좌표계 이동이 아닌, Pawn의 로컬 좌표계 기준 이동을 구현합니다.

도전 과제 2번 - 중력 및 낙하 구현 (난이도 최상)

• 인공 중력 구현
  • Tick 함수를 통해 매 프레임 중력 가속도를 직접 계산합니다.
  • 적절한 중력 상수 (예: -980 cm/s²)를 사용하여 낙하 속도를 구현합니다.
  • LineTrace 또는 SweepTrace를 사용하여 지면 충돌을 감지합니다.
  • 착지 시 Z축 속도를 0으로 초기화합니다.
• 에어컨트롤 구현 (공중 WASD 제어)
  • 공중에서는 지상 이동속도의 30~50% 정도로 제한합니다.
  • 지상/공중 상태에 따라 이동 로직을 구분하여 자연스러운 움직임을 구현합니다

---

Pawn Class

#include "TaskPawn.h"
#include "TaskPlayerController.h"
#include "Components/InputComponent.h"
#include "Components/BoxComponent.h"
#include "EnhancedInputComponent.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/SpringArmComponent.h"

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

	SceneComp = CreateDefaultSubobject<USceneComponent>(TEXT("Scene"));
	SetRootComponent(SceneComp);

	BoxCollision = CreateDefaultSubobject<UBoxComponent>(TEXT("Box Collision"));
	BoxCollision->SetupAttachment(SceneComp);

	StaticMeshComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Helicopter"));
	StaticMeshComp->SetupAttachment(SceneComp);

	StaticMeshWingComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Wing"));
	StaticMeshWingComp->SetupAttachment(StaticMeshComp);

	StaticMeshInnerComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Inner"));
	StaticMeshInnerComp->SetupAttachment(StaticMeshComp);

	StaticMeshWheelComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Wheel"));
	StaticMeshWheelComp->SetupAttachment(StaticMeshComp);

	SpringArmComp = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
	SpringArmComp->SetupAttachment(RootComponent);
	SpringArmComp->TargetArmLength = 800.0f;
	SpringArmComp->bUsePawnControlRotation = true;

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

	BoxCollision->SetSimulatePhysics(false);
	StaticMeshComp->SetSimulatePhysics(false);

	bUseControllerRotationPitch = true; 
	bUseControllerRotationYaw = true;   
	bUseControllerRotationRoll = true;
}

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

	if (UEnhancedInputComponent* EnhancedInput = Cast<UEnhancedInputComponent>(PlayerInputComponent))
	{
		// IA를 가져오기 위해 현재 소유 중인 Controller를 ASpartaPlayerController로 캐스팅
		if (ATaskPlayerController* PlayerController = Cast<ATaskPlayerController>(GetController()))
		{

			EnhancedInput->BindAction(PlayerController->MoveAction, ETriggerEvent::Triggered, this, &ATaskPawn::Move);
			EnhancedInput->BindAction(PlayerController->LookAction, ETriggerEvent::Triggered, this, &ATaskPawn::Look);
			EnhancedInput->BindAction(PlayerController->LookRollAction, ETriggerEvent::Triggered, this, &ATaskPawn::Roll);
		}
	}
}

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

	if (Controller != nullptr)
	{
		float DeltaTime = GetWorld()->GetDeltaSeconds();

		FVector DeltaLocation = FVector(
			MovementVector.X * MoveSpeed * DeltaTime, // X축 (앞뒤)
			MovementVector.Y * MoveSpeed * DeltaTime, // Y축 (좌우)
			MovementVector.Z * MoveSpeed * DeltaTime  // Z축 (상하)
		);

		AddActorLocalOffset(DeltaLocation, true);
	}
}

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

	if (Controller != nullptr)
	{
		AddControllerPitchInput(LookAxisVector.Y);
		AddControllerYawInput(LookAxisVector.X);
	}
}

void ATaskPawn::Roll(const FInputActionValue& Value)
{
	float LookRollAxisVector = Value.Get<float>();

	if (Controller != nullptr)
	{
		AddControllerRollInput(LookRollAxisVector);
	}

}

// header
#pragma once

#include "CoreMinimal.h"
#include "InputActionValue.h"
#include "GameFramework/Pawn.h"
#include "TaskPawn.generated.h"

class USpringArmComponent;
class UCameraComponent;
class UBoxComponent;

UCLASS()
class TASK07_API ATaskPawn : public APawn
{
	GENERATED_BODY()

public:
	ATaskPawn();

protected:

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Scene");
	USceneComponent* SceneComp;
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Camera");
	UBoxComponent* BoxCollision;
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "StaticMesh");
	UStaticMeshComponent* StaticMeshComp;
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "StaticMesh");
	UStaticMeshComponent* StaticMeshWingComp;
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "StaticMesh");
	UStaticMeshComponent* StaticMeshInnerComp;
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "StaticMesh");
	UStaticMeshComponent* StaticMeshWheelComp;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Camera");
	USpringArmComponent* SpringArmComp;
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Camera");
	UCameraComponent* CameraComp;

	void Move(const FInputActionValue& Value);
	void Look(const FInputActionValue& Value);  
	void Roll(const FInputActionValue& Value);

public:	
	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

	// 이동 속도
	UPROPERTY(EditAnywhere, Category = "Movement")
	float MoveSpeed = 600.0f;

	// 회전 속도 (마우스 감도 역할)
	UPROPERTY(EditAnywhere, Category = "Movement")
	float RotationSpeed = 100.0f;


};

 

PlayerController Class

#include "TaskPlayerController.h"
#include "EnhancedInputSubsystems.h"

ATaskPlayerController::ATaskPlayerController()
	: InputMappingContext(nullptr),
	MoveAction(nullptr),
	LookAction(nullptr),
	LookRollAction(nullptr)
{

}

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

	if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetLocalPlayer()))
	{
		Subsystem->AddMappingContext(InputMappingContext, 0);
	}
}


// header

#pragma once

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

class UInputMappingContext;
class UInputAction;

UCLASS()
class TASK07_API ATaskPlayerController : public APlayerController
{
	GENERATED_BODY()
	
public:
	ATaskPlayerController();

	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
	UInputMappingContext* InputMappingContext;
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
	UInputAction* MoveAction;
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
	UInputAction* LookAction;
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
	UInputAction* LookRollAction;
protected:
	virtual void BeginPlay() override;


};

 

GameMode Class

#include "TaskGameMode.h"
#include "TaskPlayerController.h"
#include "TaskPawn.h"

ATaskGameMode::ATaskGameMode()
{
	//PlayerControllerClass = ATaskPlayerController::StaticClass();

	static ConstructorHelpers::FClassFinder<APlayerController> PlayerControllerBPClass(TEXT("/Game/Blueprints/BP_TaskPlayerController"));
	if (PlayerControllerBPClass.Class != nullptr)
	{
		PlayerControllerClass = PlayerControllerBPClass.Class;
	}

	static ConstructorHelpers::FClassFinder<APawn> PlayerPawnBPClass(TEXT("/Game/Blueprints/BP_TaskPawn"));
	if (PlayerPawnBPClass.Class != nullptr)
	{
		DefaultPawnClass = PlayerPawnBPClass.Class;
	}
}


// header

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameMode.h"
#include "TaskGameMode.generated.h"

UCLASS()
class TASK07_API ATaskGameMode : public AGameMode
{
	GENERATED_BODY()
	
public:
	ATaskGameMode();
};