Unreal 공부/UE5 GameDev

[UE5] ToonTank (2)

메카인 2023. 11. 19. 13:50

ECollisionChannel

ECollisionChannel

충돌 검출 시스템의 핵심 요소 중 하나입니다. 이 열거형(enum)은 다양한 종류의 충돌 채널을 정의합니다. 게임 개발에서 충돌 채널은 객체가 어떤 다른 객체와 상호작용할 수 있는지를 결정하는 데 사용됩니다. 

References

Module Engine
Header /Engine/Source/Runtime/Engine/Classes/Engine/EngineTypes.h
Include #include "Engine/EngineTypes.h"

Syntax

enum ECollisionChannel
{
    ECC_WorldStatic,
    ECC_WorldDynamic,
    ECC_Pawn,
    ECC_Visibility,
    ECC_Camera,
    ECC_PhysicsBody,
    ECC_Vehicle,
    ECC_Destructible,
    ECC_EngineTraceChannel1,
    ECC_EngineTraceChannel2,
    ECC_EngineTraceChannel3,
    ECC_EngineTraceChannel4,
    ECC_EngineTraceChannel5,
    ECC_EngineTraceChannel6,
    ECC_GameTraceChannel1,
    ECC_GameTraceChannel2,
    ECC_GameTraceChannel3,
    ECC_GameTraceChannel4,
    ECC_GameTraceChannel5,
    ECC_GameTraceChannel6,
    ECC_GameTraceChannel7,
    ECC_GameTraceChannel8,
    ECC_GameTraceChannel9,
    ECC_GameTraceChannel10,
    ECC_GameTraceChannel11,
    ECC_GameTraceChannel12,
    ECC_GameTraceChannel13,
    ECC_GameTraceChannel14,
    ECC_GameTraceChannel15,
    ECC_GameTraceChannel16,
    ECC_GameTraceChannel17,
    ECC_GameTraceChannel18,
    ECC_OverlapAll_Deprecated,
    ECC_MAX,
}

 

ECollisionChannel의 주요 상수들

  1. ECC_WorldStatic: 일반적으로 움직이지 않는 환경 객체와의 충돌을 나타냅니다. 예를 들어, 건물, 바닥, 벽 등이 이에 해당합니다.
  2. ECC_WorldDynamic: 움직이는 객체와의 충돌을 나타냅니다. 이는 플레이어, 차량, 움직이는 플랫폼 등 다양한 동적 오브젝트를 포함할 수 있습니다.
  3. ECC_Pawn: 플레이어 캐릭터 또는 AI 캐릭터와의 충돌을 나타냅니다. 이 채널은 캐릭터의 움직임과 관련된 충돌 처리에 주로 사용됩니다.
  4. ECC_PhysicsBody: 물리 기반의 상호작용을 하는 오브젝트와의 충돌을 나타냅니다. 예를 들어, 물리 엔진으로 움직이는 상자나 기타 오브젝트들이 이에 속합니다.
  5. ECC_Visibility: 시각적으로 보이는 객체와의 충돌을 나타냅니다. 주로 라인 트레이스(Line Trace)에서 시각적 요소와의 충돌 검출에 사용됩니다.

ECollisionChannel의 사용

  • 충돌 채널은 개별 게임 오브젝트의 충돌 설정에서 지정됩니다. 이를 통해 개발자는 어떤 오브젝트가 서로 상호작용할 수 있는지를 제어할 수 있습니다.
  • 예를 들어, 플레이어 캐릭터가 벽을 통과하지 못하게 하거나, 특정 오브젝트에만 영향을 미치는 물리적 상호작용을 설정할 수 있습니다.

 

APlayerController::GetHitResultUnderCursor

사용자의 마우스 커서 아래에 있는 오브젝트와의 충돌 정보를 가져오는 데 사용됩니다. 이 함수는 주로 APlayerController 클래스 내에서 사용되며, 마우스 커서의 위치에 따라 게임 환경 내의 오브젝트와의 상호작용을 결정하는 데 유용합니다.

References

Module Engine
Header /Engine/Source/Runtime/Engine/Classes/GameFramework/PlayerController.h
Include #include "GameFramework/PlayerController.h"
Source /Engine/Source/Runtime/Engine/Private/PlayerController.cpp

Syntax

bool GetHitResultUnderCursor
(
    ECollisionChannel TraceChannel,
    bool bTraceComplex,
    FHitResult & HitResult
) const

 

함수의 주요 특징 및 사용법

  1. 충돌 정보 반환: GetHitResultUnderCursor는 마우스 커서 아래의 오브젝트와 충돌이 발생했을 경우, 해당 충돌에 대한 정보를 FHitResult 구조체로 반환합니다.
  2. 콜리전 채널 지정: 이 함수는 특정 콜리전 채널(ECollisionChannel)을 인자로 받아, 해당 채널에 해당하는 오브젝트와의 충돌만을 감지합니다. 예를 들어, ECC_Visibility 채널을 사용하면 시각적으로 보이는 오브젝트와의 충돌만을 감지합니다.
  3. 게임 상황에 따른 활용: 이 함수는 RTS(실시간 전략) 게임, RPG(롤플레잉 게임), 또는 다른 인터랙티브한 환경에서 플레이어가 마우스를 사용하여 게임 세계와 상호작용하는 데 특히 유용합니다. 예를 들어, 마우스로 특정 오브젝트를 선택하거나, 게임 환경을 탐색하는 데 사용될 수 있습니다.

사용 예시

FHitResult HitResult;
if (GetHitResultUnderCursor(ECC_Visibility, false, HitResult))
{
    // 마우스 커서 아래에 있는 오브젝트와의 충돌 정보 처리
    AActor* HitActor = HitResult.GetActor();
    if (HitActor)
    {
        // HitActor와의 상호작용 로직
    }
}

 

// Tank.cpp
void ATank::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

	if(PlayerControllerRef)
	{
		FHitResult HitResult;
		PlayerControllerRef->GetHitResultUnderCursor(ECollisionChannel::ECC_Visibility, false, HitResult);
		
		DrawDebugSphere(GetWorld(), 
				HitResult.ImpactPoint,
				25.f,
				12,
				FColor::Red,
				false,
				-1.f
	}
}

포탑 회전하기

// BasePawn.h
protect:
	void RotateTrurret(FVector LookAtTarget);

// BasePawn.cpp
void ABasePawn::RotateTrurret(FVector LookAtTarget)
{
	FVector ToTarget = LookAtTarget - TurretMesh->GetComponentLocation();
	FRotator LookAtRotation = FRotator(0.f, ToTarget.Rotation().Yaw, 0.f);
	TurretMesh->SetWorldRotation(LookAtRotation);
}


// Tank.cpp
ATank::Tick()
{
	FHitResult = HitResult;
	...
	RotateTurret(HitResult.ImpactPoint);
}

FMath::RinterpTo

회전 보간(Rotation Interpolation)을 위해 사용됩니다. 이 함수는 두 개의 FRotator 값을 받아 현재 값에서 목표 값으로 부드럽게 회전하는 데 사용됩니다. 보간 과정은 선형적이며, 지정된 보간 속도와 프레임 당의 시간 간격을 기반으로 합니다.

References

Module Core
Header /Engine/Source/Runtime/Core/Public/Math/UnrealMathUtility.h
Include #include "Math/UnrealMathUtility.h"
Source /Engine/Source/Runtime/Core/Private/Math/UnrealMath.cpp

Syntax

static FRotator RInterpTo
(
    const FRotator & Current,
    const FRotator & Target,
    float DeltaTime,
    float InterpSpeed
)

 

함수의 주요 특징 및 사용법은 다음과 같습니다

  1. 보간의 대상: FMath::RinterpTo는 현재 FRotator 값과 목표 FRotator 값을 입력으로 받습니다. 이 두 값 사이의 회전 보간을 수행합니다.
  2. 보간 속도와 시간 간격: 함수는 보간 속도와 프레임 당의 시간 간격(일반적으로 DeltaTime)도 인자로 받습니다. 이 값들은 보간이 얼마나 빨리 진행될지를 결정합니다.
  3. 부드러운 회전: 이 함수는 특히 부드러운 회전 효과를 구현할 때 유용합니다. 예를 들어, 카메라가 플레이어를 따라가거나, 객체가 다른 객체를 천천히 따라 회전할 때 사용될 수 있습니다.
  4. 실용적 사용: FMath::RinterpTo는 게임 내에서 카메라의 움직임, 캐릭터의 머리 회전, 객체의 방향 변경 등 다양한 시나리오에서 사용됩니다. 특히, 실시간으로 변화하는 타겟을 따라가는 회전 동작에 매우 적합합니다

사용 예제

FRotator CurrentRotation = ...; // 현재 회전
FRotator TargetRotation = ...; // 목표 회전
float InterpSpeed = ...; // 보간 속도
float DeltaTime = ...; // 프레임 당 시간 간격

FRotator NewRotation = FMath::RinterpTo(CurrentRotation, TargetRotation, DeltaTime, InterpSpeed);
// 회전의 보간
// BasePawn.cpp
#include "Kismet/GameplayStatics.h"

void ABasePawn::RotateTrurret(FVector LookAtTarget)
{
	FVector ToTarget = LookAtTarget - TurretMesh->GetComponentLocation();
	FRotator LookAtRotation = FRotator(0.f, ToTarget.Rotation().Yaw, 0.f);
	TurretMesh->SetWorldRotation(FMath::RinterpTo(TurretMesh->GetComponentRotation(), LookAtRotation, 
	UGameplayStatics::GetWorldDeltaSeconds(this), 25.f ));
	
}

 

 

FVector.Dist

두 벡터 사이의 유클리드 거리를 계산하는 데 사용됩니다. 이 함수는 두 FVector 객체 사이의 직선 거리를 반환하며, 3D 공간에서의 위치 차이를 측정하는 데 유용합니다.

References

Module Core
Header /Engine/Source/Runtime/Core/Public/Math/Vector.h
Include #include "Math/Vector.h"

Syntax

static float Dist
(
    const FVector & V1,
    const FVector & V2
)

 

함수의 주요 특징 및 사용법은 다음과 같습니다:

  1. 두 점 사이의 거리 계산: FVector::Dist는 두 개의 FVector 인스턴스(각각 두 점의 위치를 나타냄)를 인자로 받아, 이 두 점 사이의 직선 거리를 계산합니다.
  2. 유클리드 거리 공식 사용: 이 함수는 유클리드 거리 공식을 사용하여 두 점 사이의 거리를 계산합니다.
  3. 게임 개발에서의 활용:
    • FVector::Dist는 거리에 따른 로직 처리에 자주 사용됩니다. 예를 들어, 플레이어와 적 사이의 거리를 계산하여 적이 일정 거리 이내에 들어오면 공격하도록 할 수 있습니다.
    • 또한, 오브젝트 간의 거리를 측정하여 상호작용을 트리거하는 데에도 사용됩니다.

 

사용 예시

FVector Point1 = FVector(0.f, 0.f, 0.f); // 첫 번째 점
FVector Point2 = FVector(100.f, 100.f, 100.f); // 두 번째 점

float Distance = FVector::Dist(Point1, Point2);
// Tower 클래스
// Tower.h
public:
	virtual void Tick(float DeltaTime) override;
protected:
	virtual void BeginPlay() override;
private:
	UPROPERTY()
	class ATank* Tank;
	UPROPERTY(EditAnywhere)
	float FireRange = 700.f;

// Tower.cpp
#include "Tank.h"
#include "Kismet/GameplayStatics.h"

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

	// Find the distance to the Tank
	if(Tank)
	{
		float Distance = FVector.Dist(GetActorLocation(), Tank->GetActorLocation());
		if(Distance <= FireRange)
		{
			RotateTrurret(Tank->GetActorLocation());	
		}
		
	}
}

void ATower::BeginPlay()
{
	Super::BeginPlay();
	Tank = Cast<APawn>(UGameplayStatics::GetPlayPawn(this, 0));
}

 

FTimerManager

FTimerManager

Unreal Engine에서 시간 관련 이벤트를 관리하는 클래스입니다. 이 클래스를 사용하여 특정 함수를 일정 시간 후에 호출하거나, 반복적으로 호출하는 타이머를 설정할 수 있습니다. FTimerManager는 게임의 플레이 로직에서 주기적인 이벤트를 발생시키거나, 지연 후에 특정 작업을 수행하는 데 유용하게 사용됩니다.

 

References

Module Engine
Header /Engine/Source/Runtime/Engine/Public/TimerManager.h
Include #include "TimerManager.h"

Syntax : class FTimerManager : public FNoncopyable

 

FTimerManager의 주요 기능 및 사용법

  1. 단일 호출 타이머 설정 (SetTimer):
    • 일정 시간이 지난 후에 한 번만 호출되는 타이머를 설정할 수 있습니다. 예를 들어, 플레이어가 특정 액션을 수행한 후 일정 시간이 지나서 다음 이벤트가 발생하도록 할 때 사용됩니다.
  2. 반복 호출 타이머 설정:
    • 지정된 간격으로 반복적으로 호출되는 타이머를 설정할 수 있습니다. 이 기능은 주기적으로 특정 함수를 실행할 필요가 있을 때 유용합니다. 예를 들어, 적 캐릭터가 일정 간격으로 공격하는 경우 등에 사용됩니다.
  3. 타이머 해제 (ClearTimer):
    • 설정된 타이머를 중지하고 해제합니다. 이미 설정된 타이머를 중단할 필요가 있을 때 사용됩니다.
  4. 사용 시 주의사항:
    • 타이머에 의해 호출되는 함수는 게임의 메인 스레드에서 실행됩니다. 따라서 이 함수들은 게임의 성능에 영향을 줄 수 있으므로, 너무 빈번한 호출이나 무거운 작업은 피해야 합니다.
    • 타이머가 설정된 객체가 파괴되거나 게임이 종료될 때, 관련된 타이머들은 자동으로 해제됩니다. 하지만 필요에 따라 명시적으로 타이머를 해제하는 것이 좋습니다.

예제 코드

FTimerHandle TimerHandle;
float Delay = 5.f; // 5초 지연

// 일정 시간 후에 실행될 함수 설정
GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &AMyClass::MyFunction, Delay);

// 반복적으로 실행될 함수 설정
bool bLoop = true;
GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &AMyClass::MyFunction, Delay, bLoop);
  • 이 코드는 FTimerManager를 사용하여 5초 후에 MyFunction을 호출하는 타이머를 설정하는 예제입니다. 두 번째 예제에서는 MyFunction이 5초 간격으로 반복적으로 호출됩니다.

 

 

FTimerManager::SetTimer

시간에 기반한 이벤트를 스케줄링하는 데 사용됩니다. 이 함수는 FTimerManager 클래스의 일부로, 특정 함수를 일정 시간이 지난 후에 한 번 또는 여러 번 호출하도록 설정할 수 있습니다. SetTimer()는 게임 로직에서 지연된 액션, 주기적인 업데이트, 특정 조건을 충족시킬 때까지 기다리는 기능 등에 사용됩니다.

References

Module Engine
Header /Engine/Source/Runtime/Engine/Public/TimerManager.h
Include #include "TimerManager.h"

Syntax

template<class UserClass>
void SetTimer
(
    FTimerHandle & InOutHandle,
    UserClass * InObj,
    typename FTimerDelegate::TUObjectMethodDelegate< UserClass >::FMethodPtr InTimerMethod,
    float InRate,
    bool InbLoop,
    float InFirstDelay
)

 

기본 사용법과 특징

  1. 단일 또는 반복 호출 설정:
    • SetTimer()를 사용하여 함수를 한 번만 호출하거나 지정된 간격으로 반복적으로 호출할 수 있습니다.
  2. 인자:
    • 타이머 핸들 (FTimerHandle): 타이머를 식별하고 관리하기 위한 핸들입니다.
    • 호출될 함수: 타이머가 만료될 때 호출될 객체와 메서드를 지정합니다.
    • 지연 시간: 함수가 처음 호출되기까지의 지연 시간입니다.
    • 반복 여부: 함수를 반복 호출할지 여부를 나타내는 불리언 값입니다.
    • 반복 간격: 반복 호출의 경우, 호출 간의 시간 간격입니다.

사용 예제

// Tower.h

FTimerHandle FireRateTimerHandle;
float FireRate = 2.f;
void CheckFireCondition();


// Tower.cpp
#include "TimerManager.h"

void ATower::BeginPlay()
{
	...
	// GetWorldTimerManager는 FTimerManager 오브젝트를 반환하기 때문에 FTimerManager 헤더 파일을 포함해야 한다.
	// FTimeManager을 반환하지 포인터를 반환하지 않는다.
	GetWorldTimerManager().SetTimer(FireRateTimerHandle, this, &ATower::ChekFireCondition, FireRate, true);
}

void ATower::CheckFireCondition()
{
	if(Tank)
	{
		float Distance = FVector::Dist(GetActorLocation(), Tank->GetActorLocation());
	
		if(Distance <= FireRange)
		{
			Fire();
		}
	}
}

Projectile 클래스

// Projectile.h

private:
	UPROPERTY(EditDefaultsOnly, Category = "Combat")
	UStaticMeshComponent* ProjectileMesh;

// PProjectile.cpp

#include "Components/StaticMeshComponent.h"

AProjectile::Projectile()
{
	PrimaryActorTick.bCanEverTick = false;

	ProjectileMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Projectile Mesh"));
	RootComponent = ProjectileMesh;
}

 

 

TSubclassOf<class T>

Unreal Engine에서 클래스 참조를 안전하게 관리하는 데 사용되는 템플릿 클래스입니다. 이 타입을 사용하여 특정 클래스 또는 그 서브클래스의 참조를 저장하고, 게임 실행 중에 해당 클래스의 인스턴스를 생성하거나 조작할 수 있습니다.

 

템플릿 클래스는 에디터의 프로퍼티 창에 T 파생 클래스만 선택되도록 합니다.

 

사용 시 주의사항:

  • TSubclassOf는 클래스의 인스턴스가 아닌 클래스 자체의 참조를 나타냅니다. 따라서 실제 객체를 생성하려면, 예를 들어 SpawnActor 함수를 사용하여 인스턴스를 생성해야 합니다.
  • 이 타입은 클래스의 모든 서브클래스를 포괄할 수 있으므로, 매우 유연한 클래스 참조 관리를 가능하게 합니다.

사용 예시

// AMyCharacter 클래스 또는 그 서브클래스의 참조를 저장
TSubclassOf<AMyCharacter> CharacterClass;

// 게임 플레이 중에 해당 클래스의 인스턴스 생성
AMyCharacter* NewCharacter = GetWorld()->SpawnActor<AMyCharacter>(CharacterClass);

 

 

SpawnActor

Actor 의 새 인스턴스를 생성하는 과정을 스폰 (spawn)이라 합니다. Actor 의 스폰은 UWorld::SpawnActor() 함수를 이용합니다. 이 함수는 지정된 클래스의 새 인스턴스를 생성한 다음 새로 생성된 Actor 로의 포인터를 반환합니다.
UWorld::SpawnActor() 는 클래스 계층구조 내 Actor 클래스를 상속하는 클래스 인스턴스를 생성할 때만 사용해야 합니다.

주로 런타임 중에 동적으로 액터를 생성할 때 사용되며, 다양한 타입의 액터(캐릭터, 아이템, 구조물 등)를 게임 환경 내에 인스턴스화합니다.

 

Syntax  ( Class를 제외한 나머지는 옵션)

AActor* UWorld::SpawnActor
(
    UClass*         Class,
    FName           InName,
    FVector const*  Location,
    FRotator const* Rotation,
    AActor*         Template,
    bool            bNoCollisionFail,
    bool            bRemoteOwned,
    AActor*         Owner,
    APawn*          Instigator,
    bool            bNoFail,
    ULevel*         OverrideLevel,
    bool            bDeferConstruction
)

 

사용 시 주의사항

  • 스폰된 액터는 메모리 및 성능에 영향을 미칠 수 있으므로, 필요한 경우에만 생성하고 적절히 관리해야 합니다.
  • 액터의 생성 위치에 다른 오브젝트가 없는지, 충돌 문제가 발생하지 않는지 확인하는 것이 중요합니다.

UProjectileMovementComponent

투사체의 움직임을 관리하는 데 사용되는 컴포넌트입니다. 이 컴포넌트는 물리학 기반의 움직임, 중력의 영향, 바운싱(튕김) 효과, 속도 조절 등 투사체 특유의 동작을 구현하는 데 적합합니다.

References

Module Engine
Header /Engine/Source/Runtime/Engine/Classes/GameFramework/ProjectileMovementComponent.h
Include #include "GameFramework/ProjectileMovementComponent.h"

Syntax : class UProjectileMovementComponent : public UMovementComponent

 

주요 기능 및 특징

  1. 속도 설정:
    • 투사체의 초기 속도와 최대 속도를 설정할 수 있습니다. 이를 통해 투사체가 얼마나 빨리 움직일지 결정할 수 있습니다.
  2. 중력 설정:
    • 투사체가 중력의 영향을 받을지 여부를 설정할 수 있습니다. 이를 통해 투사체가 지면을 향해 아래로 떨어지는 등의 물리적인 동작을 구현할 수 있습니다.
  3. 바운싱 효과:
    • 투사체가 다른 오브젝트와 충돌했을 때 튕기는 정도를 설정할 수 있습니다. 이는 투사체가 벽이나 다른 오브젝트에 부딪혔을 때의 반응을 나타냅니다.
  4. 충돌 처리:
    • 투사체의 충돌 처리 방식을 설정할 수 있으며, 이를 통해 특정 오브젝트와 충돌 시 어떤 동작을 할지 결정할 수 있습니다.
  5. 경로 시뮬레이션:
    • 투사체의 경로를 시뮬레이션하며, 이를 통해 예상 경로를 미리 계산하고 시각화할 수 있습니다.

예제 사용법

UProjectileMovementComponent는 주로 투사체를 발사하는 무기나 기타 발사체 생성 로직에 사용됩니다. 예를 들어, 캐릭터가 수류탄을 던지거나, 총에서 총알이 발사될 때 이 컴포넌트를 활용할 수 있습니다.

// Projectile 클래스 내부에서 UProjectileMovementComponent 생성 및 설정
UProjectileMovementComponent* ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileMovement"));
RootComponent = ProjectileMesh;

ProjectileMovement->bAutoActivate = false; // 자동 활성화 설정
ProjectileMovement->InitialSpeed = 3000.f; // 초기 속도 설정
ProjectileMovement->MaxSpeed = 3000.f; // 최대 속도 설정
ProjectileMovement->bRotationFollowsVelocity = true; // 속도 방향에 따른 회전 설정
ProjectileMovement->bShouldBounce = true; // 튕김 효과 설정

 

  • 이 코드는 투사체의 움직임을 관리하는 컴포넌트를 생성하고 기본 설정을 구성하는 예시입니다. 초기 속도, 최대 속도, 바운싱 설정 등을 통해 투사체의 동작을 제어할 수 있습니다.

 

OnComponentHit  ( UPrimitiveComponent )

OnComponentHit은 UPrimitiveComponent의 이벤트 중 하나로, 컴포넌트가 다른 오브젝트와 물리적으로 충돌했을 때 발생합니다. 이 이벤트를 사용하여 충돌 시 수행할 특정 작업을 정의할 수 있습니다. (멀티캐스트 델리게이트)

Unreal Engine에서 사용되는 이벤트 핸들러로, 액터의 컴포넌트가 다른 오브젝트와 충돌했을 때 발생하는 이벤트를 처리합니다. 이 핸들러는 주로 충돌 감지와 관련된 로직을 구현하는 데 사용됩니다.

Syntax : FComponentHitSignature OnComponentHit

 

주요 특징 및 사용법

  1. 충돌 이벤트 감지:
    • OnComponentHit은 액터의 컴포넌트가 다른 오브젝트와 물리적으로 충돌했을 때 호출됩니다.
  2. 핸들러 시그니처:
    • 이 이벤트 핸들러는 보통 다음과 같은 시그니처를 가집니다:
void OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit);
  • 여기서 HitComponent는 충돌한 컴포넌트, OtherActor는 충돌한 다른 액터, OtherComp는 충돌한 다른 컴포넌트, NormalImpulse는 충돌에 의한 정규 충격량, Hit은 충돌에 대한 상세 정보를 담고 있습니다.

3. 이벤트 바인딩:

  • OnComponentHit 이벤트를 사용하기 위해서는 먼저 이를 컴포넌트의 OnComponentHit 델리게이트에 바인딩해야 합니다.

예제 코드

  • 이 코드는 MyComponent의 OnComponentHit 이벤트에 OnHit 함수를 바인딩하고, 충돌이 발생했을 때 수행할 로직을 구현하는 예시입니다.
// 컴포넌트에 OnComponentHit 이벤트 바인딩
MyComponent->OnComponentHit.AddDynamic(this, &AMyActor::OnHit);

// OnComponentHit 핸들러 구현
void AMyActor::OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)
{
    // 충돌 관련 로직 처리
}

 

사용 시 주의사항

  • 충돌 처리 로직은 게임의 성능에 영향을 줄 수 있으므로, 필요한 경우에만 실행되도록 주의 깊게 구현해야 합니다.
  • 모든 컴포넌트가 OnComponentHit 이벤트를 발생시키는 것은 아니며, 충돌 이벤트를 발생시키려면 컴포넌트가 충돌 검출을 위해 적절히 설정되어 있어야 합니다.

OnComponentHit를 사용하면, 개발자는 충돌 발생 시 정교한 반응과 상호작용을 게임 내에 구현할 수 있습니다. 이는 플레이어의 경험을 향상시키고, 게임의 현실감을 높이는 데 중요한 역할을 합니다.

 

FComponentHitSignature

언리얼 엔진에서 사용되는 이벤트 시그니처로, 주로 액터의 컴포넌트가 다른 액터의 컴포넌트나 액터와 충돌할 때 발생하는 이벤트를 처리하는 데 사용됩니다. 이 시그니처는 컴포넌트의 충돌 관련 이벤트를 위한 델리게이트(delegate) 정의에 사용되며, 특정 충돌 이벤트가 발생했을 때 호출되는 콜백 함수들을 위한 형식을 제공합니다.

 

References

Module Engine
Header /Engine/Source/Runtime/Engine/Classes/Components/PrimitiveComponent.h
Include #include "Components/PrimitiveComponent.h"

Syntax

 

FComponentHitSignature의 기본 구조

FComponentHitSignature는 충돌 이벤트에 대한 정보를 제공하는 인자들을 포함하고 있으며, 일반적으로 다음과 같은 매개변수를 가집니다:

  1. Hit Component (UPrimitiveComponent):* 충돌 이벤트를 발생시킨 컴포넌트입니다.
  2. Other Actor (AActor):* 충돌에 관련된 다른 액터입니다.
  3. Other Component (UPrimitiveComponent):* 충돌에 관련된 다른 컴포넌트입니다.
  4. Normal Impulse (FVector): 충돌에 의해 발생한 정상적인 충격량을 나타내는 벡터입니다.
  5. Hit (const FHitResult&): 충돌에 대한 상세한 정보를 담고 있는 FHitResult 구조체입니다.

FComponentHitSignature의 사용

  • 충돌 처리: 이 시그니처를 사용하는 델리게이트는 액터의 컴포넌트가 다른 컴포넌트나 액터와 충돌했을 때 특정 동작을 수행하도록 할 수 있습니다.
  • 이벤트 바인딩: FComponentHitSignature 타입의 델리게이트를 사용하여, 개발자는 충돌 이벤트가 발생했을 때 호출될 콜백 함수들을 연결할 수 있습니다.

게임 개발에서의 중요성

FComponentHitSignature는 게임 개발 과정에서 다음과 같은 중요한 역할을 합니다:

  • 리얼타임 충돌 반응: 게임 오브젝트가 서로 충돌할 때 실시간으로 반응하고, 그에 따른 효과를 적용할 수 있도록 합니다.
  • 커스텀 로직 실행: 특정 충돌 조건에서 커스텀 게임 로직을 실행할 수 있게 해줍니다. 예를 들어, 플레이어가 벽에 부딪히면 건강 수치를 감소시키는 등의 작업을 할 수 있습니다.

이와 같이 FComponentHitSignature는 충돌 관련 이벤트 처리에 있어 핵심적인 역할을 하는 것으로, 복잡한 게임 환경에서 다양한 상호작용과 효과를 구현하는 데 필수적인 요소입니다.

 
 
 

OnTakeAnyDamage (AActor)

Unreal Engine에서 사용되는 이벤트 핸들러로, 액터가 어떠한 형태의 데미지를 받았을 때 호출됩니다. 이 이벤트는 데미지 시스템과 밀접하게 연관되어 있으며, 게임 내에서 캐릭터나 오브젝트가 데미지를 입었을 때의 반응을 처리하는 데 사용됩니다.

 

Syntax : FTakeAnyDamageSignature OnTakeAnyDamage

 

OnTakeAnyDamage의 기능 및 사용법

  1. 데미지 감지:
    • OnTakeAnyDamage 이벤트는 액터가 데미지를 받을 때마다 발생합니다. 이 데미지는 충돌, 공격, 환경 요소 등 다양한 원인으로부터 발생할 수 있습니다.
  2. 이벤트 핸들러 시그니처:
    • OnTakeAnyDamage 핸들러는 일반적으로 다음과 같은 시그니처를 가집니다:
    •  
void OnTakeAnyDamage(AActor* DamagedActor, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, AActor* DamageCauser);
  •  여기서 DamagedActor는 데미지를 받은 액터, Damage는 받은 데미지의 양, DamageType은 데미지의 유형, InstigatedBy는 데미지를 준 플레이어 또는 AI 컨트롤러, DamageCauser는 데미지를 유발한 액터 또는 오브젝트를 나타냅니다.

3. 이벤트 바인딩:

  • OnTakeAnyDamage 이벤트를 사용하기 위해서는 먼저 이를 액터의 OnTakeAnyDamage 델리게이트에 바인딩해야 합니다.

4. 예제 코드

// 액터의 생성자 또는 BeginPlay에서 이벤트 바인딩
OnTakeAnyDamage.AddDynamic(this, &AMyActor::OnDamaged);

// OnTakeAnyDamage 핸들러 구현
void AMyActor::OnDamaged(AActor* DamagedActor, float Damage, const UDamageType* DamageType, AController* InstigatedBy, AActor* DamageCauser)
{
    // 데미지 처리 로직
}

 

 

UGameplayStatics::ApplyDamage

Unreal Engine에서 액터에게 데미지를 적용하는 데 사용되는 정적 함수입니다. 이 함수는 게임 내에서 캐릭터나 오브젝트에게 특정 양의 데미지를 주는 것을 구현하는 데 사용됩니다. ApplyDamage는 데미지를 입히는 액터, 데미지의 양, 데미지를 준 액터, 데미지 타입 등 다양한 정보를 기반으로 작동합니다.

References

Module Engine
Header /Engine/Source/Runtime/Engine/Classes/Kismet/GameplayStatics.h
Include #include "Kismet/GameplayStatics.h"
Source /Engine/Source/Runtime/Engine/Private/GameplayStatics.cpp

Syntax

static float ApplyDamage
(
    AActor * DamagedActor,
    float BaseDamage,
    AController * EventInstigator,
    AActor * DamageCauser,
    TSubclassOf< class UDamageType > DamageTypeClass
)

 

기능 및 사용법

  1. 데미지 적용:
    • ApplyDamage 함수는 특정 액터에게 데미지를 적용합니다. 이 데미지는 그 액터의 TakeDamage 함수를 통해 처리될 수 있습니다.
  2. 필수 인자:
    • DamagedActor: 데미지를 받을 액터입니다.
    • BaseDamage: 적용할 데미지의 양입니다.
    • EventInstigator: 데미지를 준 액터를 제어하는 컨트롤러입니다.
    • DamageCauser: 데미지를 유발한 액터입니다.
    • DamageTypeClass: 적용될 데미지의 타입을 정의하는 UDamageType 클래스입니다.
  3. 예제 코드:
AActor* DamagedActor = ...; // 데미지를 받을 액터
float DamageAmount = 10.f; // 데미지 양
AController* InstigatorController = ...; // 데미지를 준 컨트롤러
AActor* DamageCauser = ...; // 데미지를 준 액터
UClass* DamageType = UMyDamageType::StaticClass(); // 데미지 타입

UGameplayStatics::ApplyDamage(DamagedActor, DamageAmount, InstigatorController, DamageCauser, DamageType);
  • 이 코드는 DamagedActor에게 DamageAmount만큼의 데미지를 DamageCauser와 InstigatorController에 의해 DamageType의 타입으로 적용합니다.

ApplyDamage의 중요성

ApplyDamage 함수를 사용하면, 개발자는 게임 내에서 캐릭터나 오브젝트가 서로 상호작용하고 영향을 미치는 복잡한 시나리오를 구현할 수 있습니다. 예를 들어, 플레이어가 적에게 공격을 가했을 때 데미지를 계산하고 적의 건강 상태를 감소시키는 로직, 특정 환경 요소가 캐릭터에게 데미지를 주는 상황 등을 처리할 수 있습니다.

이러한 기능은 게임의 전투 시스템, 상호작용 및 게임 플레이의 다이내믹을 구축하는 데 핵심적인 역할을 합니다.

 

Instigator

Unreal Engine에서 "Instigator"는 주로 액터(Actor) 클래스의 멤버로 사용되며, 어떤 이벤트나 액션의 시작을 일으킨 액터를 가리킵니다. 예를 들어, 데미지를 주는 액터, 이벤트를 시작한 액터 등이 이에 해당할 수 있습니다. Instigator는 게임 내에서 발생하는 다양한 상호작용과 이벤트의 원인을 추적하는 데 유용하게 사용됩니다.

Instigator의 역할 및 사용법

  1. 이벤트 원인 추적:
    • Instigator는 특정 이벤트나 액션을 일으킨 액터를 참조합니다. 이를 통해 이벤트의 원인이 되는 액터를 파악하고, 이에 따른 적절한 반응을 구현할 수 있습니다.
  2. 데미지 처리에서의 활용:
    • 예를 들어, 어떤 액터가 다른 액터에게 데미지를 주는 경우, 데미지를 준 액터는 Instigator로 설정될 수 있습니다. 이를 통해 데미지를 받은 액터는 누가 자신에게 데미지를 주었는지 알 수 있습니다.
  3. 상호작용과 반응:
    • 게임 내에서 발생하는 다양한 상호작용(예: 아이템 사용, 공격, 트리거 활성화)에서 Instigator는 해당 상호작용을 시작한 액터를 나타냅니다. 이 정보는 게임 로직에서 해당 액터의 행동에 대한 반응을 결정하는 데 사용됩니다.

예제 사용법

void AMyProjectile::OnHit(...)
{
    AActor* MyInstigator = GetInstigator();
    // 여기서 MyInstigator는 이 프로젝타일을 발사한 액터를 가리킵니다.

    if (MyInstigator)
    {
        // Instigator를 기반으로 로직 처리
    }
}

예

이 예제에서는 프로젝타일(AMyProjectile)이 충돌했을 때, 그 프로젝털을 발사한 액터(Instigator)를 기반으로 특정 로직을 처리하는 방법을 보여줍니다.

주의사항 및 활용

  • Instigator의 중요성: Instigator는 게임 내에서 발생하는 이벤트의 원인을 추적하고, 이에 따른 적절한 반응을 구현하는 데 중요한 역할을 합니다. 이를 통해 게임 플레이에 깊이와 복잡성을 더할 수 있습니다.
  • 적절한 설정: Instigator는 액터가 생성되거나 이벤트를 시작할 때 적절히 설정되어야 합니다. 잘못된 Instigator의 설정은 게임 로직의 오류로 이어질 수 있습니다.
  • 다양한 상황에서의 활용: Instigator는 데미지 처리, 이벤트 트리거, AI 행동 결정 등 다양한 상황에서 활용될 수 있으며, 게임의 전반적인 상호작용과 플레이어 경험에 영향을 미칩니다.

GetInstigatorController(), GetInstigator() 등이 있다.

 

UDamageType::StaticClass()

UDamageType::StaticClass()는 Unreal Engine에서 데미지 타입을 식별하는 데 사용되는 함수입니다. Unreal Engine의 데미지 시스템에서는 다양한 종류의 데미지를 구분하기 위해 UDamageType 클래스 또는 그 서브클래스를 사용합니다. StaticClass() 함수는 UDamageType 클래스의 메타데이터를 반환하며, 이는 데미지 처리 시 해당 타입의 데미지를 식별하는 데 사용됩니다.

기능 및 사용법

  1. 데미지 타입 식별:
    • UDamageType 클래스는 데미지의 속성과 행동을 정의합니다. 예를 들어, 화염 데미지, 전기 데미지, 물리적 충격 데미지 등을 구분할 수 있습니다.
    • StaticClass() 함수는 UDamageType 클래스의 클래스 타입을 반환합니다. 이 정보는 데미지를 처리할 때 해당 타입의 데미지로 식별하는 데 사용됩니다.
  2. 데미지 처리 시 활용:
    • ApplyDamage와 같은 함수에서 데미지 타입을 파라미터로 전달할 때 UDamageType::StaticClass()를 사용합니다.
  3. 커스텀 데미지 타입:
    • 개발자는 UDamageType을 상속받는 자신만의 커스텀 데미지 타입을 만들 수 있으며, 이를 통해 특정한 데미지 처리 로직을 구현할 수 있습니다.

예제 코드

AActor* DamagedActor = ...;
float DamageAmount = 50.0f;
AController* EventInstigator = ...;
AActor* DamageCauser = ...;

UGameplayStatics::ApplyDamage(DamagedActor, DamageAmount, EventInstigator, DamageCauser, UDamageType::StaticClass());

이 코드는 UDamageType::StaticClass()를 사용하여 ApplyDamage 함수에 데미지 타입을 전달하는 예제입니다. 이는 기본 데미지 타입을 나타내며, 데미지 처리 시 이를 기준으로 처리 로직이 실행됩니다.

활용

UDamageType::StaticClass()와 같은 데미지 타입 식별자는 게임 내에서 다양한 종류의 데미지 처리와 관련된 로직을 구현하는 데 중요한 역할을 합니다. 예를 들어, 다른 데미지 타입에 따라 다른 반응을 보이는 캐릭터 AI, 데미지에 따른 다양한 시각적 및 오디오 효과 등을 구현할 수 있습니다.

 

AActor::Destroy

Destroy 메소드는 게임 세계에서 액터를 제거하는 데 사용됩니다.

사용 예제

// 액터 클래스 메소드 내에서 가정
this->Destroy();

주의사항

  • 지연된 제거: 액터의 실제 게임 세계에서의 제거는 프레임 또는 게임의 업데이트 주기가 끝날 때까지 지연될 수 있습니다. 따라서 Destroy를 호출한 직후에는 액터가 여전히 짧은 시간 동안 게임 세계에 존재할 수 있습니다.
  • 가비지 컬렉션: Unreal Engine은 메모리 관리를 위해 가비지 컬렉션을 사용합니다. 액터가 파괴되면, 가비지 컬렉션 과정에서 메모리가 해제될 것으로 표시됩니다.
  • 참조 처리: 액터를 파괴할 때는 특히 게임의 다른 부분이 액터에 대한 참조를 가지고 있는 경우 주의가 필요합니다. 이러한 참조는 무효한 포인터나 파괴된 액터에 대한 접근 시도를 피하기 위해 적절히 처리되어야 합니다.