느긋한 주인장

Unreal FOverlapResult

추향 — Thu, 12 Feb 2026 17:14:10 +0900

FOverlapResult

FOverlapResult는 언리얼엔진에서 Overlap검사 결과를 담는 구조체입니다.

OverlapMultiByChannel이나 OverlapMultiByObjectType 같은 함수를 호출했을 때, "어떤 액터/컴포넌트와 겹쳤는지"에 대한 정보를 담아주는 타입니다.

UE 5.4

전에는 그냥 써도 됐었던 거 같은데 빌드할 때 오류가 있길래 보니까 5.4부터는 FOverlapResult를 사용하기 위해서는 Include를 따로 해줘야 하는 것 같더라고요.

#include "Engine/OverlapResult.h"

찾아보니까 CollisionQueryResult.h안에 정의되어 있어서 다른 충돌 관련 헤더를 Include 하면 자연스럽게 따라왔는데 5.4부터 바뀌었다고 하네요.

사용방법.

#include "Engine/OverlapResult.h"

//예시.
void func(){
	const FVector SelfLoc = GetActorLocation();
	FCollisionShape Shape = FCollisionShape::MakeSphere(Radius);
	FCollisionQueryParams Params;
	Params.AddIgnoredActor(this);
	TArray<FOverlapResult> Hits;
	DrawDebugSphere(GetWorld(), SelfLoc,Radius,30,FColor::Red,false,1);
	bool bAny = GetWorld()->OverlapMultiByChannel(Hits,SelfLoc,FQuat::Identity,ECC_Pawn,Shape,Params);
	if (!bAny)return nullptr;
	for (const FOverlapResult& Hit : Hits) {
		AActor* Other = Hit.GetActor(); 
	}
}

이벤트 뷰어를 이용해 시스템 비정상 종료 원인 찾기

추향 — Mon, 3 Nov 2025 23:12:00 +0900

최근 서브컴퓨터가 이유없이 꺼지는 일이 있었다.

주로 게임을 트레이로 오래 켜놓았을 때 꺼져서, 처음엔 그래픽 드라이버 충돌로 인한 종료라고 생각했다.

그래서 드라이버를 재설치해봤지만, 증상은 여전 발생했다.

이번 글은 이 오류를 해결한 과정을 기록한 것이다.

아직까지 증상이 발생되지 않는걸로 보아, 일단은 해결된 것으로 보인다.

윈도우 이벤트 뷰어.

정확한 종료 원인을 찾아보기 위해 이벤트 뷰어를 사용해봤다.

win키 + R을 누르면 나오는 실행창에 eventvwr.msc를 입력하면 이벤트 뷰어를 실행할 수 있다.

이벤트 뷰어에서 Windows로그->시스템으로 들어가면 각종 시스템 이벤트를 확인할 수 있다.

여러가지 시스템 이벤트들이 보이는데 컴퓨터가 갑자기 꺼지는 정도의 이벤트는 "위험"이나 "오류" 정도의 수준으로 기록되기 때문에 "현재 로그 필터링"을 사용해서 한번 걸러냈다.

한번 걸러내고 보니 여러가지가 오류들이 보였다.

한 달 사이에 약 3번정도 강제종료가 됐는데,

그 사이에 보인 주요 이벤트 ID는 16, 10010, 1796, 20, 38, 41, 6008, 161,162 등이었다.

생각보다 오류들이 많았는데 이 부분은 잘 모르는 내용이라 GPT에게 물어봤다.

확인해본 결과, 컴퓨터 종료에 대한 내용은 41, 6008이었고 꺼지기 직전의 로그들을 살펴봤다.

161,162가 있었다.

161 : 장치 전원 관리나 하드웨어 절전 관련 오류.

162 : 시스템이 절전 모드로 진입 실패.

이런 내용이었다.

아무래도 게임을 트레이모드로 켜놓은 상태에서 절전모드로 들어갔던 것이 원인이 되었을 수 있겠다는 생각이 들었다.

그래서 제어판-> 전원 옵션-> 고급옵션에서 절전에 관한 내용을 확인해보았다.

역시 절전관련된 내용들이 있었고, 이 부분들을 모두 꺼줬다.

아무래도 이 부분은 잘 모르는 내용이라 GPT에 찾아가며 해결했고, 사실 이것때문에 해결된건지도 잘 모르겠다.

하지만 벌써 3일째 컴퓨터가 꺼지지 않고 있는 것으로 보아 절전이 문제의 원인이었을 가능성이 높아보인다.

Unreal 로딩 구현하기 cpp

추향 — Tue, 24 Dec 2024 12:25:51 +0900

언리얼 로딩 구현하기

아래의 글은 언리얼에서 로딩 화면 구현에 대한 글입니다.

로딩을 구현하는 방법은 여러가지가 있지만 이 글은 그중 한가지를 보여주는 글입니다.

맵 로드가 시작되기 전에 로딩 화면을 설정하고, 최소 2초 동안 표시되도록 설정했습니다.

로딩 화면은 LoadingWidget으로 보여지며, 맵이 로드된 후 로딩 화면을 종료합니다.

언리얼 로딩 구현하기 cpp

UGameInstance는 게임을 종료하거나 맵을 전환할 때도 유지됩니다.

이러한 특징으로 인해 맵 전환시에도 필요한 데이터를 유지하거나 로딩 화면을 표시하는 등의 작업에도 좋다고 생각해서 SlashGameInstace를 하나 만들어서 사용했습니다.

아래 코드들을 사용하기 위해서는 모듈을 추가해야 합니다.

 "MoviePlayer"

USlashGameInstance.h

#pragma once

#include "CoreMinimal.h"
#include "Engine/GameInstance.h"
#include "SlashGameInstance.generated.h"

class UUserWidget;
/**
 * 
 */
UCLASS()
class SLASH_API USlashGameInstance : public UGameInstance
{
	GENERATED_BODY()
public:
	TSoftObjectPtr<UWorld> GetLevel(FString LevelName);
protected:
	//게임 인스턴스가 처음 생성될 때 호출됨.
	virtual void Init()override;
	UFUNCTION()//맵 로드가 시작되기 전에 로딩화면을 설정.
	void OnPreLoadMap(const FString& PreLoadMap);
	UFUNCTION()//맵이 로드된 후 로딩 화면을 종료.
	void OnDestinatioonWorldLoaded(UWorld* LoadedWorld);
	UPROPERTY(EditDefaultsOnly)
	TSoftClassPtr<UUserWidget> LoadingWidgetClass;

private:
	//String을 키로 사용해서 저장된 Level을 가져옴
	UPROPERTY(EditDefaultsOnly, Category = "Level")
	TMap<FString, TSoftObjectPtr<UWorld>> MapList;
};

USlashGameInstance.cpp

#include "SlashGameInstance.h"
#include "Blueprint/UserWidget.h"
#include "MoviePlayer.h"

void USlashGameInstance::Init()
{
    Super::Init();
	FCoreUObjectDelegates::PreLoadMap.AddUObject(this,&ThisClass::OnPreLoadMap);
	FCoreUObjectDelegates::PostLoadMapWithWorld.AddUObject(this, &ThisClass::OnDestinatioonWorldLoaded);
}

void USlashGameInstance::OnPreLoadMap(const FString& PreLoadMap)
{
    //위젯 동기적으로 생성.
    const auto LoadingWidget = CreateWidget<UUserWidget>(this, LoadingWidgetClass.LoadSynchronous(), TEXT("LoadingScreen"));
    TSharedRef<SWidget> LoadingSWidgetPtr = LoadingWidget->TakeWidget();
    FLoadingScreenAttributes LoadingScreenAttributes;
    LoadingScreenAttributes.bAutoCompleteWhenLoadingCompletes = true;
    //로딩화면 최소 2초 유지.
    LoadingScreenAttributes.MinimumLoadingScreenDisplayTime = 2.f;
    //기본 로딩 위젯
    //LoadingScreenAttributes.WidgetLoadingScreen = FLoadingScreenAttributes::NewTestLoadingScreenWidget();
    LoadingScreenAttributes.WidgetLoadingScreen = LoadingSWidgetPtr;
    //로딩 시작.
    GetMoviePlayer()->SetupLoadingScreen(LoadingScreenAttributes);
}
void USlashGameInstance::OnDestinatioonWorldLoaded(UWorld* LoadedWorld)
{   //로딩 종료
    GetMoviePlayer()->StopMovie();
}
TSoftObjectPtr<UWorld> USlashGameInstance::GetLevel(FString LevelName)
{
    //맵 가져오기.
    if (MapList.IsEmpty()) {
        UE_LOG(LogTemp, Warning, TEXT("Map List Is Null Please Fill"));
        return nullptr;
    }
    return *MapList.Find(LevelName);
}

init() : 게임 인스턴스가 처음 생성될 때 호출됨.

PreLoadMap : 맵 로드가 시작되기 전에 로딩화면을 설정.

PostLoadMapWithWorld : 맵이 로드된 후 로딩 화면을 종료.

블루프린트(위젯 만들기) + 설정.

적당한 LoadingWidget을 만듭니다.

없으면 위의 코드에서 그냥 주석처리 해놓은것으로 사용합니다.

만들어놓은 GameInstance를 블루프린트로 만들어서 로딩위젯 클래스를 넣어줬습니다.

게임 인스턴스에 코드를 썻으니 이걸 사용하기 위해 Edit->ProjectSettings->GameInstance->BP_SlashGameInstance로 설정해줬습니다.

결과 영상.

코드에 적어놓은 FLoadingScreenAttributes::NewTestLoadingScreenWidget()과 LoadingSWidgetPtr을 사용한 경우 모두 들어있는 영상입니다.

//LoadingScreenAttributes.WidgetLoadingScreen = FLoadingScreenAttributes::NewTestLoadingScreenWidget();
LoadingScreenAttributes.WidgetLoadingScreen = LoadingSWidgetPtr;

https://youtu.be/oBn3IHvAtHI

언리얼 위젯 애니메이션 C++

추향 — Wed, 18 Dec 2024 17:38:55 +0900

언리얼 위젯 애니메이션

언리얼 블루프린트에서 Widget Animation을 만들고 Cpp에서 사용하는 방법에 대한 글입니다.

위젯 애니메이션 만들기 Blueprint.

저는 보통 블루프린트에서 위젯과 애니메이션을 먼저 만듭니다.

순서는 이렇게 되겠네요.

1. 위젯 만들기 : 애니메이션을 적용할 위젯을 만듭니다.

2. 애니메이션 만들기 : 애니메이션 작업을 시작하기 위해 빈 애니메이션을 만듭니다.

3. 위젯 요소 선택하기 : 애니메이션을 적용할 위젯 요소(텍스트, 버튼 등등)를 선택합니다.

4. 열쇠모양을 누르기 : 이걸 눌러놓으면 Properties가 변경될 때 자동으로 Key를 추가합니다.

5. 프레임에 Key 추가 : 타임라인에 Key를 추가하여 애니메이션 동작을 설정합니다.

아래 사진은 예시로 보여드리는 사진입니다.

초기상태.

Scale : 3배
Render Opacity : 0

최종상태.

Scale : 1배.
Render Opacity : 1

위젯이 크고 안 보이는 상태로 있다가 점점 작아지고 보이게 됩니다.

위젯 애니메이션 변수 연결 / 재생 C++

위젯 애니메이션 변수 연결

블루프린트로 만들었던 애니메이션을 C++에서 사용하기 위해 변수를 연결해주겠습니다.

블루프린트로 만들었던 애니메이션과 이름을 똑같이 해서 UWidgetAnimation을 만들어줍니다.

UPROPERTY(Transient,meta = (BindWidgetAnim))
class UWidgetAnimation* MenuAnim;

간단하게 설명하면 이겁니다.

Transient : 이건 휘발성 데이터, 임시로 사용할거니까 저장 ㄴㄴ.

meta = (BindWidgetAnim) : 블루프린트에서 만든 애니메이션 중 이름이 같은 걸 자동으로 연결해 줘!

애니메이션 재생.

PlayAnimation으로 UWidgetAnimation을 불러주면 됩니다.

(아래 예시는 Menu를 부르면 위젯 애니메이션이 작동하고, Menu를 사용하는 동안 게임 내 시간이 흐르지 않습니다.)

void UMenuWidget::NativeConstruct()
{
	Super::NativeConstruct();
	//#include "Animation/WidgetAnimation.h"
	PlayAnimation(MenuAnim);
	if (GetOwningPlayer()) {
	FInputModeUIOnly InputMode;
	GetOwningPlayer()->SetInputMode(InputMode);
	GetOwningPlayer()->SetShowMouseCursor(true);
	}
	//#include "Kismet\GameplayStatics.h"
	UGameplayStatics::SetGlobalTimeDilation(GetWorld(), 0.f);
}

위젯 애니메이션 실행.

위에서 보여드린 예제를 실행한 영상입니다.

언리얼 부서지는 오브젝트

추향 — Wed, 18 Dec 2024 05:12:14 +0900

언리얼 부서지는 오브젝트

언리얼5에서 부서지는 오브젝트를 만드는 방법에 대한 내용입니다.

Geometry Collection

Fracture Mode를 선택하고 New를 눌러줍니다.

이름 설정하고 저장하면 Geometry Collection이 생성됩니다.

생성된 Geometry Collection을 선택하고 다양한 Fracture설정 중에서 Planar를 골라보겠습니다.

이후 Fracture Hierachy를 들어가서 0 으로 되어있는 SM_Claypot_01a를 눌러줍니다.

여기가 잘리겠구나 라는 생각이 들도록 만드는 무언가가 나타납니다.

아래 사진에서는 항아리 중간에 생겼네요.

Fracture을 눌러 줍니다.

대충 이런식으로 0 밑에 두개가 생겼습니다.

이제 이걸 위에서 떨어뜨려보면!

아까 설정한 부분으로 두조각이 되는것을 확인할 수 있었습니다.

Breakable Actor

기존에 만들었던 Actor는 부서지는 오브젝트 말고 다른 내용도 포함되어 있어 새로운 Actor를 만들었습니다.

특별한 것이 필요한 것은 아니라서 간단하게 블루프린트로 만들었습니다.

1. Breakable Actor.

Actor 하나를 만들어서 GeometryCollection(cpp에선 UGeometryCollectionComponent)을 추가합니다.

GeometryCollection에 위에서 만든 GeometryCollection을 넣어줍니다.

2. GeometryCollection 설정.

Chaos Physics->Events->Notify Break=true;

Collision->Generate Overlap Events=true;

auto Activate = false;

3. Break Event추가.

GeometryCollection-> Add Event-> On Chaos Break Event추가.

부서질때마다 사운드가 나오게 됩니다.

FieldSystem [Weapon]

Weapon Actor.

Weapon Actor에서 공격할 때 Create Fields 함수를 실행하도록 설정했습니다.

1. 공격 시 Trace실행.

-공격 시 Trace를 실행하여 충돌하는지 확인합니다.

2. 충돌 대상 확인.

- 충돌한 경우 Actor인지 확인합니다.

3. CreateFields 함수 호출.

- 충돌한 대상이 Actor인 경우, CreateFields함수를 실행합니다.

- 해당 함수는 C++에서 BlueprintImplementableEvent로 설정되어 있어, 블루프린트에서 마저 구현했습니다.

Component.

FieldSystem 추가.

RadialVector 추가.

RadialFalloff 추가.

FieldSystemMetaDataFilter 추가 -> Details-> Field -> ObjectType=Destruction으로 설정.

CreateFields함수.

(여기서부턴 틀릴 수 있음.)

Set Radial Fallloff : 필드 효과가 거리(반경)에 따라 감소하는 정도를 설정.

-Field Magnitude : 필드의 최대 세기 설정.

-Min Range : 필드 효과가 최소한으로 작동하는 거리.

-Max Range : 필드 효과가 최대한으로 적용되는 거리.

-Default Value : 필드의 기본 값. 영향을 받지 않는 영역에 적용될 값.

-Sphere Radius : 필드가 영향을 미치는 최대 반경.

-Center Position : 필드의 중심 위치.

-Falloff Type : 거리 감소 방식.

Field System Meta Data Filter : 필드 효과를 특정 오브젝트에만 적용하기 위해 메타데이터 기반 필터링.

-Meta Data : 필드가 적용될 대상 오브젝트의 조건을 정의.

Add Transient Field : Field System Component에 필드를 추가하는 역할.

-Enable Field : 필드 활성화 여부를 설정.

-Physics Type : 물리 효과의 타입 설정.

* External Strain (외부 압력을 적용하는 필드 타입, 물체를 파괴함)

* Linear Force (선형 방향으로 힘을 적용, 파괴되지 않은 물체 특정 방향으로 밀어냄).

이건 솔직히 빼도 될거같기도.

Set Radial Vector : Radial Vector는 방사형으로 힘의 방향과 세기를 설정.

-Field Magnitude : 필드의 힘의 세기.

-Center Position : 필드 중심의 위치를 설정.

실행 결과.

무기에 Chaos Field System을 적용해 Breakable Actor를 파괴하는 예시 동영상.

https://youtu.be/tSogCG-M02A?si=GCT-uj0Gu5Ja4rJT

Chaos Field Unreal 문서.

언리얼 RPG 프로젝트 2 C++

추향 — Mon, 16 Dec 2024 23:19:12 +0900

언리얼 RPG 프로젝트 2 C++

GAS(GamePlay Ability System)프레임워크를 사용해보고 싶어서 사용해 봤습니다.

(GAS에 대한 자세한 내용은 아래.)

GAS를 사용하는데 RPG가 제일 맞는 것 같았습니다.

게임에 대해.

개발 언어: C++, Blueprint

개발 엔진: Unreal 5.4

개발 환경(실행 환경): Window 11

코드.

깃허브 주소.

https://github.com/ykarr/RPG_Blade_1.git

GitHub - ykarr/RPG_Blade_1

Contribute to ykarr/RPG_Blade_1 development by creating an account on GitHub.

github.com

기능.

캐릭터.

-Attribute

처음 시작할 때 동기적으로 데이터를 가져와서 Attribute를 적합니다.

-Weapon Spawn / 아이템 장착

게임을 시작할 때 무기를 소환하고 소켓에 장착.

Weapon Class to Spawn만 바꾸면 됩니다.

-가벼운 공격.

Light Attack Montage를 여러 개 만들어서 콤보에 따라 다른 공격이 나가도록 설정했습니다.

데미지 계산식.

if (UsedLightAttackComboCount !=0) {
	//콤보가 1인경우(시작공격) 데미지증가 0
	const float DamageIncreasePercentLight = (UsedLightAttackComboCount - 1) * 0.05f+1.f;
	BaseDamage *= DamageIncreasePercentLight;
	//Debug::Print(TEXT("ScaledBaseDamageLight"), BaseDamage);
}

-강공격

강공은 공격력만 다르고 가벼운 공격과 비슷합니다.

데미지.

if (UsedHeavyAttackComboCount != 0) {
	//콤보가 1인경우(시작공격) 데미지증가 0
	const float DamageIncreasePercentHeavy = (UsedHeavyAttackComboCount - 1) * 0.15f + 1.f;
	BaseDamage *= DamageIncreasePercentHeavy;
	//Debug::Print(TEXT("ScaledBaseDamageHeavy"), BaseDamage);
}

-분노상태.

분노 게이지를 모아서 분노 상태로 들어갈 수 있도록 만들었습니다.

분노 상태에서는 원거리 공격을 할 수 있고, 사용중일 때 무적입니다.

Enemy의 원거리 공격과 다르게 Overlap으로 설정해서 일정 거리까지 닿아도 없어지지 않고 작동합니다.

-특별한 공격.

범위 안의 적을 공격하거나, 어떤 위치에 있는 적에게 순간이동하며 공격하거나 하는 쿨타임이 존재하는 능력입니다.

-막기

적의 특별한 공격을 제외하고 막을 수 있습니다.

아슬아슬하게 막은 경우 잠시동안 시간이 느려집니다.

-구르기

Roll Ability를 실행하면, 특정한 방향으로 구르게 됩니다.

난이도에 따라 구르기 레벨이 달라지고 구르기 레벨에 따라 이동거리가 달라집니다.

-타겟락

범위 안에 Enemy가 있는 경우 가장 가까운 적에게 Target Lock을 사용할 수 있습니다.

TargetLock을 사용하면 PlayerCharacter가 Targeting된 적을 바라보고 Strafing으로 움직임이 바뀝니다.

https://youtu.be/pJh1PRzDDQo

-죽음.

캐릭터가 죽을 경우 Player Death Ability를 실행하고, UI가 실행됩니다.

게임을 다시 실행 / 메뉴로 이동 / 게임 종료.

-UI 애니메이션

언리얼 위젯 애니메이션 C++

언리얼 위젯 애니메이션언리얼 블루프린트에서 Widget Animation을 만들고 Cpp에서 사용하는 방법에 대한 글입니다.위젯 애니메이션 만들기 Blueprint.저는 보통 블루프린트에서 위젯과 애니메이션을

intunknown.tistory.com

-GameplayTag

Unreal GameplayTag c++

Unreal GameplayTag최근 Unreal프로젝트를 만들면서 GameplayAbility를 사용하면서 GameplayTag를 많이 사용해 보았다.그러면서 에디터 내에서 태그를 추가하고 관리하는 방법이 아닌, 따로 파일을 만들어서

intunknown.tistory.com

-쿨타임.

Ability에 있는 기능을 이용해 구현하고 CoolTime UI를 위해 GamePlayAbility Tick을 구현해 사용했습니다.

GameplayAbility Tick 구현 C++

GameplayAbility Tick기본적으로 GameplayAbility자체는 Tick을 제공하지 않기 때문에 GameplayAbility에서 Tick을 사용하기 위해서는 추가적인 설정이 필요합니다.Tick구현 - Ability Task.GameplayAbility에서 Tick을 사용

intunknown.tistory.com

Enemy.

-Attribute

처음 시작할 때 비동기적으로 작동합니다.

비동기적으로 Status를 적용하고, 무기를 불러오는 등...

-아이템 장착.

Enemy가 소환된 후 무기를 소환하고, 무기를 장착합니다.

-공격

플레이어가 근접 공격이 가능한 영역에 들어오면, AI는 EQS를 사용하여 주변 환경을 평가하고, 이를 기반으로 공격하고 빠지는 전투를 수행합니다.

-막을 수 없는 공격

UI가 나오면서 막을 수 없는 공격을 경고합니다.

-아이템 드롭.

Enemy가 죽으면서 아이템을 드롭합니다.

일정한 확률로 드롭하고, 거기서 일정한 확률로 Health/Range를 채워줍니다.

(GamePlayEffect)

-원거리 Enemy

Character가 근처로 막을 수 없는 공격을 진행하거나 도망갑니다.

원거리에서 공격하고 EnemyProjectileAttackAbility을 이용해 Projectile Actor를 소환해서 공격합니다.

-보스

보스가 나타날 경우 보스의 HP가 나타나고, HP가 일정 이하로 줄어들면 보스가 아닌 Enemy를 소환합니다.

-소환

Wave마다 랜덤 한 종류의 정해진 수의 Enemy를 소환합니다.

-UI

Enemy의 머리 상단에 표시할 HealthBar UI.

-AI

AI는 Behavior Tree를 이용해 행동을 구현했고, EQS(Environment Query)를 사용했습니다.

Behavior Tree : AI의 행동을 트리 구조로 구성하여, 상태에 행동을 제어.

EQS : AI가 주변 환경을 평가하고, 이를 기반으로 최적의 행동을 선택하도록 돕는 시스템.

Item

-회복 아이템.

아이템을 사용할 수 있을 때 상호작용 아이콘이 나타납니다.

-무기.

무기에 InputMappingContext와 무기에 맞는 Animation, Ability, WeaponStatus 등을 넣어 사용합니다.

WeaponStatus-> 난이도에 따라 데미지가 달라집니다.

기타 기능.

-로딩.

Unreal 로딩 구현하기 cpp

언리얼 로딩 구현하기아래의 글은 언리얼에서 로딩 화면 구현에 대한 글입니다.로딩을 구현하는 방법은 여러가지가 있지만 이 글은 그중 한가지를 보여주는 글입니다.맵 로드가 시작되기 전에

intunknown.tistory.com

-난이도 설정.

위젯을 통해 난이도를 설정->USaveGame으로 저장합니다.

게임을 시작할 때는 USaveGame->PlayerCharcter->GameModeBase형식으로 됩니다.

(USaveGame을 사용하면 데이터가 저장되어 게임을 껐다 켜도 데이터가 유지됩니다.)

알게된점.

Gameplay Ability System은 액터의 능력 및 스킬을 구축하기 위한 프레임워크입니다.

능력과 Actor를 분리시켜 의존성을 없애고, 유연한 개발이 가능하도록 해줍니다.

AbilitySystemComponent

-액터의 모든 어빌리티를 관리.

- 캐릭터, NPC 등 특정 액터에 부착.

GameplayAbility

-액터가 수행할 수 있는 능력을 정의.

- 공격, 힐링, Targeting 등의 스킬이나 행동.

AbilityTask

-GameplayAbility 내에서 세부적인 동작을 정의.

- 충돌 감지 등.

GameplayTag

-능력, 상태, 효과등을 식별하고 분류하는 데 사용.

- 태그를 이용해 죽었는지 살았는지부터 공격 중인지 화염상태인지 등 여러 가지 상태 식별.

Gameplay Attribute

-캐릭터의 수치를 관리.

- 캐릭터의 체력, 마나, 방어력, 공격력 등의 수치를 관리.

GameplayEffect

-능력이나 아이템 사용 시 적용되는 효과 정의.

- 체력 포션을 먹었을 때 피 50회복/피 10초간 지속회복.

GameplayCue

-능력 발동 시 발생하는 연출(비주얼, 사운드).

- 캐릭터가 스킬을 사용할 때 나오는 이펙트와 사운드 등.

아쉬운 점.

혼자서 개발하는 것이 제일 아쉬운 점이었던 것 같습니다.

혼자서 개발하다 보니 리소스를 구하는 부분이나 Level을 구성하는 부분이 너무 오래 걸렸습니다.

또한 GAS를 사용해보고 싶어서 시작한 프로젝트였기 때문에 GAS도 공부하면서 웬만하면 C++을 위주로 하고 싶어서 블루프린트 코드들을 C++로 바꾸고 진행하다 보니 이런 코드들이 블루프린트에서는 보이지만 C++에서는 보이지 않는 것들이 몇 개 있어서 이런 것들을 찾고, 만들고 하다 보니 시간이 너무 오래 걸렸습니다.

느낀 점.

GAS(GamePlay Ability System)를 사용하며 이 시스템의 강력함과 유연함을 직접 체감할 수 있었습니다.

하지만, 소규모 프로젝트에서는 GAS가 과하게 느껴지는 부분도 많았습니다.

GAS는 확장성이 뛰어나고, 능력이나 효과를 체계적으로 관리할 수 있는 구조 덕분에 대규모 프로젝트에서는 매우 유용한 도구가 될 것이라고 생각합니다. 하지만 소규모 개발에서는 초기 설정과 학습 곡선이 조금 부담스러웠습니다.

"과한 것이 반드시 좋은 것은 아니다" 라는 말을 GAS를 공부하고 적용하면서 떠올리게 되었습니다.

GAS를 공부하고 적용하는데 들인 시간에 비해, 간단한 기능이라면 직접 구현했을 경우 더 빠르게 개발을 완료할 수 있었을 겁니다.

찾아보니까 GAS는 대규모 시스템을 목표로 설계되었기 때문에 간단한 능력 구현에도 불필요한 구조와 시스템이 포함되는 경우가 많았습니다. 그럼에도 불구하고, GAS는 한번 익혀두면 꽤 쓸만하다는 생각이 들었고, 특히 네트워크 동기화가 필요한 멀티 플레이 환경에서는 큰 장점이 될 것이라고 생각합니다.

결론적으로, GAS는 프로젝트의 규모와 필요성에 따라 선택적으로 사용하는 것이 가장 효과적일 것 같고, 작은 규모의 프로젝트나 간단한 기능이라면 직접적인 방식으로 구현하는 것이 효과적일 것이라고 느꼈습니다.

실행 영상.

https://youtu.be/bNOfcP864uY

언리얼 RPG 프로젝트 1 C++

추향 — Mon, 16 Dec 2024 23:17:40 +0900

언리얼 RPG 프로젝트 1 C++

언리얼 엔진을 처음 접하며 만든 첫 프로젝트로 기억합니다.

당시 언리얼 엔진에 대해 전혀 알지 못했기 때문에, Unreal Engine의 기본적인 사용법과 C++을 활용한 게임 개발의 핵심 요소를 배우는 것이 목표였습니다.

게임에 대해.

개발 언어: c++, blueprint

개발 엔진: unreal5

개발 환경(실행 환경): window 10

코드.

깃허브 주소:

https://github.com/ykarr/RPG_Slash_1.git

GitHub - ykarr/RPG_Slash_1

Contribute to ykarr/RPG_Slash_1 development by creating an account on GitHub.

github.com

기능.

캐릭터.

1. 상태.

캐릭터의 상태를 체계적으로 관리하기 위해 Enum Class를 활용했습니다.

각 상태는 캐릭터가 게임 내에서 취할 수 있는 다양한 행동과 상태를 명확히 정의하고, 이를 통해 캐릭터의 동작을 직관적이고 쉽게 관리할 수 있도록 설계했습니다.

2. 공격.

무기를 소지한 경우 공격이 가능합니다.

무기의 Collision 결과를 기반으로 각 Actor에게 GetHit 인터페이스를 통해 적중 결과를 전달합니다.

Unreal5 Hit C++

Unreal5 Hit C++ 안녕하세요. 저번 글에서 공격 애니메이션을 추가했습니다. 이번 글에서는 Box Component를 이용해 공격한 위치를 보여주도록 하겠습니다. [프로그래밍/언리얼] - Unreal5 Attack Animation C++ U

intunknown.tistory.com

3. 피격.

플레이어 캐릭터가 피격당한 경우.

Weapon에 적용된 Damage만큼의 피해를 입고 UI를 업데이트합니다.

이후, 피격당했을 때 내적을 계산합니다.

Unreal5 Dot Product(내적) C++

Unreal5 Dot Product(내적) C++ 저번글에서 간단한 Hit를 구현했는데 좀 더 살을 붙여보려고 합니다. 이번 글에서는 Dot Product를 이용해 Player가 때리는 각도를 알아보려고 합니다. [프로그래밍/언리얼] - U

intunknown.tistory.com

이후 외적을 계산해서 맞은 방향을 알아냅니다.

Unreal5 맞은 방향 알아내기 CrossProduct(외적) c++

Unreal5 맞은 방향 알아내기 CrossProduct c++ Dot Product는 두 벡터의 사잇각이 0-180도 사이에 있을 때 값을 계산합니다. 즉, 두 벡터가 평행하면 값이 최대가 되고, 직교하면 0이 되며, 반대 방향이면 값

intunknown.tistory.com

그러면 이제 맞은 방향에 맞게 Hit Animation을 실행합니다.

4. 회피.

사용할 때마다 Stamina를 사용하고, State를 EActionState::EAS_Dodge로 설정해서 구르는 동안 공격등을 실행하지 못하도록 했습니다.

5.Attribute

Attribute Component를 이용해 값을 계산해서 뱉어줍니다.

시간이 지나면 다시 회복되는 스태미나는 Tick을 이용해 회복시켜 줬습니다.

6. FootIK

inverse Kinematics(역운동학, IK)는 일반적으로 로봇공학에서 사용되는 개념으로, 끝단의 위치가 주어졌을 때, 그 위치를 만족시키기 위해 로봇의 관절 각도를 계산하는 기술입니다.

이 기술을 사용해서 캐릭터의 발 위치를 보다 자연스럽게 해줬습니다.

Unreal5 Foot IK

Unreal5 Foot IK *그냥 공부하면서 작성하는 글입니다. 이 글은 이전글과 이어지는 글이므로 이해하기 위해서 이전 글이 필요할 수 있습니다. [프로그래밍/언리얼] - Unreal5 점프 애니메이션 Unreal5 점

intunknown.tistory.com

7. 아이템 장착/ 해제.

아이템을 장착할 수 있는 상태라면 장착하고, 장착할 수 없는 상태라면 장착할 수 없도록 구현했습니다.

장착키를 다시 누르면 현재 장착한 무기를 다른 곳에 있는 소켓에 넣어둡니다.

무기를 들고 있을 때 버리기 키를 누르면 무기가 줍기 전 상태로 돌아갑니다.

8. UI

UI는 HUD랑 뭐 별거 없으니까... 생략하겠습니다.

Enemy.

1.Enemy의 상태.

위의 Player에서 있었던 Enum을 이용해 상태관리를 하고, 그 상태를 바탕으로 Enemy의 행동이 정해집니다.

간단하게 말하면, 순찰->발견->추격->공격->순찰 순입니다.

2. 순찰 / 추격.

평소에는 Patrol target 중에서 랜덤 한 위치로 순찰을 다니다가 UPawnSensingComponent에 플레이어가 포착되면 플레이어를 추격하게 됩니다.

3. 공격.

공격을 할 수 있는 위치까지 추격하게 되면, Enemy는 공격을 시작하게 됩니다.

Enemy가 위협적일 수 있도록 MotionWarping을 이용해 어느 시점까지 공격하면서 플레이어를 향해 이동합니다.

4. 피격.

Enemy가 피격당하는 경우 Player와 비슷합니다.

다만, 피격당하는 순간 머리 위에 HealthBar가 생성되고 일정 시간 피격당하지 않으면 보이지 않는 상태로 돌아갑니다.

5. Death

Enemy가 죽은 경우 State가 바뀌게 되며 행동을 멈춥니다.

이후 아이템이 떨어집니다.

item

1. Gold

Breakable Object를 부셨을 때, Gold가 되는 아이템이 드롭됩니다.

언리얼 부서지는 오브젝트

언리얼 부서지는 오브젝트언리얼5에서 부서지는 오브젝트를 만드는 방법에 대한 내용입니다.Geometry CollectionFracture Mode를 선택하고 New를 눌러줍니다.이름 설정하고 저장하면 Geometry Collection이 생

intunknown.tistory.com

2. Soul

Enemy가 죽은경우 Soul을 드롭합니다.

Soul에 접근하면 획득할 수 있습니다.

3. Weaon

Weapon Actor Class를 만들어서 무기 생성 및 장착합니다.

장착하는 경우 무기 Effect와 무기 장착을 위해 생성된 Collision을 비활성 상태로 만들어줍니다.

Unreal5 무기 생성 및 장착 C++

Unreal5 무기 생성 및 장착 C++. *이 글은 공부하면서 작성하는 글이며, 이전글과 이어지는 글이므로 이해하기 위해서는 이전글 확인이 필요할 수 있습니다. [프로그래밍/언리얼] - Unreal5 Overlap C++ Unr

intunknown.tistory.com

공격 Animation에 Notify를 사용해서 무기가 공격하는 중에만 Collision을 검사할 수 있도록 설정합니다.

Unreal5 무기 Collision C++

Unreal5 무기 Collision C++ 안녕하세요. 이번 글에서는 무기 Collision 설정으로 공격 가능한 상태일 때만 Collision이 활성화되도록 하겠습니다. [프로그래밍/언리얼] - Unreal5 맞은 방향 알아내기 CrossProduct

intunknown.tistory.com

Collision을 이용해 맞았는지 확인하고, 같은 태그(같은 Enemy)인지 검사한 후 Damage와 Effect를 실행합니다.

알게 된 점.

언리얼 엔진을 처음 배우며 다양한 요소를 경험할 수 있었고, 이를 통해 게임 개발에 필요한 틀을 제공받아 제작 과정에서 큰 도움을 받았습니다.

또한, 학부 시절에는 상속이 중요하다는 것을 머리로는 알았지만 실감하기 어려웠습니다.

이번 프로젝트를 통해 상속을 활용하면 코드 중복을 줄이고, 새로운 기능 추가나 기존 기능 수정이 훨씬 수월해진다는 점을 체감할 수 있었습니다.

(여기서는 상속만 이야기 했지만 여러가지가 있습니다.)

한 줄 요약: 언리얼 엔진에 많이 익숙해진 것 같고, 기본의 중요성을 깨달았다.

아쉬운 점.

처음 언리얼 엔진을 사용해 진행한 프로젝트였던 만큼, 혼자 작업하다 보니 아쉬운 점이 많았습니다.

RPG 장르는 구현해야 할 기능이 많고, 공부해야 할 내용과 필요한 리소스도 많았습니다.

이로 인해 한정된 시간과 경험만으로는 출시할 만한 퀄리티를 달성하기까지의 거리가 너무 멀게 느껴져, 결국 프로젝트를 빠르게 마무리하게 되어 아쉬움이 남았습니다.

물론 시간자체는 충분히 있었지만, 리소스를 구하거나 레벨을 구성하는 과정에서 어려움이 많았습니다. 또한, 언리얼 엔진에 대한 이해도가 부족해 인터넷에서 자료를 찾아가며 진행하다보니, 더 진행하면 과연 이 프로젝트를 끝낼 수 있을지 의문이 들었습니다.

또한, 효율적인 코드 작성 방법에 대한 확신도 없었고, 언리얼의 다양한 기능(ex.Behavior Tree)도 몰라서 제대로 활용하지 못해 프로젝트를 진행하면서 한계를 느끼기도 했습니다.

이러한 경험들은 아쉬움으로 남았지만, 동시에 많은 것을 배우고 고민할 수 있는 기회가 되었습니다.

느낀 점.

확실히 이런 프로젝트를 진행하면서 만들고, 버그에 걸리고, 디버깅을 통해 문제를 해결하며 방법을 검색하는 과정에서 코드에 점점 더 익숙해지고 C++과 언리얼의 이해도가 높아지는 것을 느꼈습니다.

다양한 기능을 프로젝트를 진행하며 공부할 수 있었고, 학부생 시절에는 중요하다고 생각했지만 실감하지 못했던 개념들의 중요성을 이번 프로젝트를 통해 더 깊이 느낄 수 있었습니다.

실행 영상.

해당 프로젝트 실행 영상.

https://youtu.be/_WJOPLFuXFY?si=Zqt6kIl7i6i4wmH1

언리얼 멀티플레이 FPS C++

추향 — Sun, 15 Dec 2024 06:56:15 +0900

언리얼 멀티플레이 FPS C++

멀티플레이 게임에 대해 공부하기 위해 만든 프로젝트입니다.

멀티플레이 FPS를 개발하면서 Steam이나 Lan매칭을 위한 멀티플레이 플러그인을 만들어서 사용했습니다.

처음에는 그냥 멀티플레이 FPS를 C++로 만들면서 공부나 해볼까 하면서 진행한 프로젝트였는데 이 프로젝트를 진행하면서 생각보다 멀티플레이 게임을 만들때 생각해야되는 것이 많구나 하는 것을 느낀 프로젝트였습니다.

프로젝트.

개발 언어 : c++ & 블루프린트(약간)

개발 엔진 : Unreal5.4

개발 환경(실행 환경) : 윈도우 11.

멀티플레이 FPS 코드(멀티플레이 플러그인 포함).

https://github.com/ykarr/MultiFPS

GitHub - ykarr/MultiFPS: unreal

unreal. Contribute to ykarr/MultiFPS development by creating an account on GitHub.

github.com

기능.

1. 멀티플레이 플러그인.

1.1 멀티플레이 메인화면.

1.2 멀티플레이 호스트 메뉴.

멀티플레이 가능 인원 설정, Lan연결인지 Steam연결인지 설정해서 Session생성했습니다.

1.3 멀티플레이 세션 찾기 메뉴.

LAN이나 Online(Steam) 선택해서 세션을 찾고, 10초동안 해당 세션에 들어갈 수 있도록 만들었습니다.

2. 캐릭터.

2.1 팀 선택.

세션에 입장하면 팀을 선택할 수 있습니다.

Select Team Widget(Client)을 통해 팀을 선택하면 GameMode(Server)에서 각 팀의 정해진 스폰 위치중 랜덤한 위치에 정해진 팀 캐릭터를 스폰시키게 됩니다.

2.2 1인칭 캐릭터.

처음 캐릭터를 만들 때 고민을 좀 했습니다.

상대방에게 몸은 모두 보이고, 그림자도 모두 보여야 하는데 1인칭 게임이다보니 머리가 Player에게 보이면 안된다고 생각했습니다. 그래서 이것을 해결하기 위해 고민을 좀 했습니다.

결국 좋은 방법이 생각나지 않아서 Mesh를 두개 사용해서 해결했습니다.

1개는 SkeletonMesh->bOwnerNoSee = true; 를 설정해서 Player에게 보이지 않고 상대방에게만 보이지 않도록 설정했습니다. 나머지 한개는 GetMesh()->bOnlyOwnerSee = true;로 설정해서 플레이어에게만 보이도록 설정하고 Mesh의 Head부분만 숨겼습니다. 이렇게 해서 그림자도 bOwnerNoSee 설정을 해놓은 Mesh만 보이도록 설정해서 겉으로 보기에는 다 정상적으로 나오게 만들었습니다.

2.3 상태 관리.

Enum을 이용해 상태관리.

걷는중인지, 뛰는중인지, 움크리고 있는지 이부분을 Enum과 Tarray를 이용해 스택형으로 관리했습니다.

Ex) 뛰다가 움크리면 움크리기가 실행되고, 움크리기를 그만하면 다시 키를 누르지 않아도 뛰고있게됩니다.

UnArm, Pistol, Rifle 이렇게 3가지 경우가 있는데 이 경우를 Enum을 이용해 관리했습니다.

이 Enum을 무기 장착 Soket설정 등등에 사용했습니다.

2.4 Attribute

DataTable을 활용해 캐릭터의 Status를 설정했습니다.

2.5 Aim offset

아래의 함수를 사용해 AimDirection을 구하고 AimDirection값으로 Aim Offset을 설정했습니다.

void ABattleCharacterBase::CalculateAimDirection()
{
	FRotator Rot = UKismetMathLibrary::NormalizedDeltaRotator(GetControlRotation(), GetActorRotation());
	AimDirection = Rot.Pitch;
}

캐릭터의 컨트롤러 기준 회전값과 캐릭터의 월드 기준 회전값 간의 차이를 계산하고, 이 값을 -180 ~ 180범위로 정규화해서 Rot 변수에 저장합니다.

만약 Rot.pitch의 값이 음수라면 해당 플레이어의 Aim이 아래를 향하고 있는 것이고, 양수라면 하늘을 향하는 것입니다.

2.6 아이템 장착.

무기 아이템(Collision)에 Player가 접근했을 때 무장상태가 아닌경우 손에 무기 아이템을 장착하고 손이나 등에 무기가 있는경우 무장되지 않은 무기를 소켓에 장착합니다.

아이템을 장착하면서 UI 업데이트가 진행됩니다.

2.7 총 장전.

장전 애니메이션은 현재 장착중인 무기 아이템에서 가져와서 실행했습니다.

장전 애니메이션은 일시적인 행위라서 나중에 들어올 플레이어들에게 영향을 끼치지 않아도 되므로, 굳이 RepNotify하지 않아도 됩니다. 이 부분은 따로 아래에 설명을 작성했습니다.

2.8 총 쏘기.

클라이언트에서 총을 쏘는 키를 누르면 서버에서 Shoot코드를 실행하고, 총 사운드와 이펙트를 Multicast로 했습니다.

Linetrace를 활용해 Linetrace의 위치가 Head bone인경우 Head Shoot 그 외의 나머지인경우 BodyShoot으로 설정해 받는 데미지가 다르도록 설정했습니다.

탄약 수나 사격 조건은 서버에서만 확인할 수 있도록 만들었고, 총을 쏠 때 사운드나 이펙트를 Multicast로 호출해서 모든 클라이언트가 동일한 사운드와 이펙트를 실행하도록 만들었습니다.

즉, 클라이언트에서는 서버 RPC 호출만 담당했습니다.

3. 아이템.

3.1 데이터 테이블.

아이템에 대한 정보는 데이터 테이블을 사용해 관리했습니다.

아이템 이름, Type, Thumbnail아이콘, 해당 무기의 사용 애니메이션, 사운드, 이펙트, 데미지 등을 저장해 사용했습니다.

3.2 아이템 장착(상호작용)

아이템을 장착하는 상호작용은 Collision으로 처리했습니다.

Begin overlap함수등을 만들어 특정 Collision에 Player Tag를 가지고 있는 Actor가 접근하면 장착하거나 하지않거나를 수행하는 방식으로 코드를 작성했습니다.

아이템을 버리는 경우 특정 Actor가 Collision 영역에 들어왔을때만 호출되므로, 버리는게 모두 완료된 이후 begin overlap이 동작하도록 bool함수를 설정해서 들고있다가 떨어뜨린 무기라면 Sphere Collision 범위 밖으로 나갔다 와야 다시 상호작용 할 수 있도록 설정했습니다.

알게된점.

멀티플레이 게임에서의 서버의 역할.

RepNotify와 Multicast의 차이와 사용이유.

Multicast.

기능: 서버에서 실행된 함수를 모든 클라이언트에게 브로드캐스트.

제한: Multicast는 실행 시점에 연결된 클라이언트만 영향을 받음.

ex) 플레이어가 무기를 장착하는 애니메이션을 실행하기 위해 Multicast를 사용하면 이후 서버에 접속한 클라이언트는 이 애니메이션을 볼 수 없음.

적합: 일시적 효과

ex) 폭발, 파티클 등의 일시적 효과.

RepNotify

기능: 변수가 변경될 때 해당 변경을 클라이언트에 알리고, 추가적으로 서버와 클라이언트에서 이를 처리할 기회 제공.

특징: 서버에서 변수가 변경되면 클라이언트로 자동 복제.

변수가 변경될 때에만 클라이언트의 OnRep_함수가 호출됨.

지속적으로 유지되어야하는 정보에 적합.( 게임에 전송해야 할 시각적 변경 사항이 있는 경우. )

모든 클라이언트가 항상 최신 상태를 유지하도록 보장.

새로운 클라이언트가 서버에 연결되더라도 현재 상태를 동기화 받을 수 있음.

--------------------------------------------------------

* NONE : 기본값이며 변화를 안 알린다
* Replicated : 다른 머신 모두가 그 변화를 알 수 있도록한다
-> 설정이 되어 있으면, 변화가 다른 머신에 반드시 전달 되다는 보장이 있다
* 엄청난 양의 리플리케이션을 하는 경우에는 네트워크 지연(랙)이 발생할수 있다. 빠르긴 하지만 즉시 작업은 아니다

* RepNotify : Replicated키워드의 역활을 그대로 한다. 여기에 추가로 변수가 변할 떄, 누군가가 변경을 하면, 이에 대한 반응을 할 수 있는 기회를 준다. 함수를 호출하여 작업을 할 수 있는 기회를 얻는다

*주의점

- Replication관련 옵션에서 Replicated와 RepNotify는 차이가 있는데.

Replicated: 계속 감지하고

RepNotify: 변화가 있을때에만 감지한다.

- C++에서는 RepNotify는 수동으로 호출해줘야 하지만 블루 프린트에서는 편의상 자동으로 클라이언트와 서버에서 호출한다. 만약 한번만 실행이 되어진다면 그것은 함수수호출 리플리케이션이 적절하다.(폭발 같은 일시적인것)

하지만 계속 유지되어 지는것은 변수 리플리케이션을 사용하는것이 좋다.

아쉬운 점.

혼자서 처음 만들어보는 멀티플레이 게임이다보니 이게 왜 버그가 났는지에 대해 단시간에 찾기가 쉽지 않았고, Replicated 문제가 발생하면 Delay로 해결해서 이 부분에서 문제가 생기는 경우도 많았습니다.

처음에 가벼운 마음으로 시작한 프로젝트라서 평소와 다르게 한개의 클래스에 과도하게 많은 기능을 넣어 수정하기가 힘든 부분이 있었습니다.

평소 Standalon프로젝트를 많이 개발하면서 만든 기능들은 다른 방식으로 구현해보고 싶어서 구현한 부분이 몇가지 있는데 만들고 보니 이 부분들이 좀 아쉬웠습니다.

느낀점.

블루프린트로 만들어진 멀티플레이 FPS를 참고하며 C++로 개발을 시작했습니다.

진행 화정에서 C++과 블루프린트에서 멀티플레이가 다르게 동작하는 부분이 있다는 것을 알게 되었습니다.

이러한 차이점을 이해하고 해결하기 위해 관련 자료를 찾아보며 멀티플레이에 대한 전반적인 이해를 높일 수 있었습니다.

특히 블루프린트에서 자동으로 처리 되는 부분을 C++에서는 수동으로 구현해야 하는 경우도 있었고, 예상치 못한 버그가 자주 발생해 이를 수정하며 많은 공부가 되었습니다.

또한 멀티플레이 게임 특성상 솔로 게임과는 달리 동기화 문제를 신경 써야 했고, 동일한 기능을 개발하더라도 코드가 더 길어지고 다양한 문제가 발생했습니다.

처음에는 간단한 멀티플레이 FPS를 만들어보자 하는 가벼운 마음으로 시작했지만, 프로젝트를 진행하면서 멀티플레이 환경에서 고려해야 할 요소들이 훨씬 많다는 것을 깨닫게 되는 프로젝트였습니다.

플레이 영상.

https://youtu.be/4WwZydjSaW0?si=drN332raHMK-MLAc

언리얼 호러게임 프로젝트 c++

추향 — Tue, 10 Dec 2024 03:16:07 +0900

언리얼 호러게임 프로젝트 C++

이 글에 나오는 호러게임은 언리얼을 공부하던 초반에 만든 프로젝트입니다.

그 당시 언리얼 엔진의 기능에 익숙하지 않았고, C++에 더 익숙해지기 위해 개발을 시작했습니다.

그래서 특별한 아이디어보다는 공포게임에서 흔히 볼 수 있는 요소들을 우선적으로 구현해보았습니다.

공포게임은 스토리와 레벨 디자인이 가장 중요하다고 생각합니다.

이 부분은 제가 자신이 없어서 프로젝트를 중단하게 되었습니다.

나중에 특별하게 추가할 수 있는 요소가 생각나면 나중에 다시 개발할 계획이지만, 이 프로젝트를 이어서 계발하기보다는 처음부터 다시 시작할 생각입니다.

게임에 대해.

개발 언어 : C++

개발 엔진 : Unreal 5.1 (현재는 5.4.4)

개발 환경(실행 환경) : 윈도우 11.

코드.

https://github.com/ykarr/HorrorGameTest

GitHub - ykarr/HorrorGameTest

Contribute to ykarr/HorrorGameTest development by creating an account on GitHub.

github.com

기능.

1. 아이템.

아이템 주변에 접근하면 화살표가 나타납니다.

아이템을 주울 수 있는 거리에 접근하면 "E" key UI가 나타납니다.

구현을 하기위해 아이템 Actor에 Begin Overlap, EndOverlap 함수를 만들어서 사용했습니다.

그러다보니 여러가지 불편한게 많아서 그냥 캐릭터에 Collision을 만들어서 처리하거나 다른 방법으로 구현하는게 많았나 하는 생각이 많이 드는 기능이었습니다.

(아이템 주변에 플레이어가 접근하면 아이템 위치를 알려주기 위해 Collision을 사용했는데 Collision이 너무 크고 많아서 레벨을 수정하거나 할 때 불편함.)

2. 인벤토리.

인벤토리에 아이템이 없을 때는 아이템 칸이 활성화되지 않습니다.

(마우스를 올려도 색이 변하거나 하지 않음.)

아이템이 존재하면 아이템 칸이 활성화되며, 아이템 위에 마우스를 올리면 Tooltip(아이템에 대한 정보)을 보여줍니다.

아이템을 클릭하면 사용할 것인지, 살펴볼 것인지, 떨어뜨릴 것인지 결정할 수 있습니다.

Examin을 누르면 이렇게 동작합니다.

Examin을 구현하기 위해 맵에서 조금 떨어진 공간에 Examin Actor를 만들어서 SceneCapture2D를 이용해 랜더링 정보를

Render Target(실시간으로 업데이트되는 텍스처)에 넘겨줬습니다.

이후 받은 랜더링 정보를 Material형식으로 만들었습니다.

이걸 플레이어의 UI에 Image형식으로 보여줬습니다.

3. 숨을 수 있는 오브젝트 (Locker)

Linetrace를 사용해서 Locker에 숨거나 Locker에서 나올 수 있게 구현했습니다.

Locker는 Enemy의 추격을 피할 수 있는 위치로 이에 대한 설명은 아래 Enemy쪽에서 더 적을 예정입니다.

Arrow Component를 이용해 로커에 들어갈 때의 위치와 방향, 들어갔을 때의 위치와 방향, 나올 때의 위치와 방향을 설정했습니다.

Thimeline과 float curve를 이용해 부드럽게 로커에 들어가거나 나올 수 있도록 TimelineEvent들을 활용했습니다.

4. 정보를 알려주는 메모 아이템.

이 아이템은 글이 써져 있을 뿐이지 Examin과 거의 동일하기 때문에 설명은 생략합니다.

한글폰트 설정.

언리얼 한글폰트

언리얼 한글폰트. UE5에서 한글 폰트를 적용하는 방법에 대한 글입니다. 해당 글에서 사용한 폰트는 눈누라는 사이트에서 받았습니다. UMG에 한글폰트 적용하기. UMG 간단합니다. 다운받은 TTF 파일

intunknown.tistory.com

5. 상호작용 가능한 자물쇠.

비밀번호는 C++의 생성자에서 생성합니다.

이후 필요하다면, Beginplay에서 비밀번호를 수정할 수 있습니다.

자물쇠에 상호작용하면 SetViewTargetWithBlend함수를 사용해 플레이어의 시점에서 설정된 Camera Component 시점으로 부드럽게 변경됩니다.

이후 자물쇠에 넣어놓은 UI위젯과 상호작용해 비밀번호를 설정맞추면 됩니다.

비밀번호를 맞추면 자물쇠개 풀리는 애니메이션이 발생하고 사라집니다.

시점변경에 관련된 영상.

언리얼 카메라 시점 변경 c++

언리얼 카메라 시점 변경 c++언리얼에서 c++을 이용해 카메라 시점을 변경 하는 방법에 대해 보여주는 글입니다.이 글에서는 'SetViewTargetWithBlend'함수를 활용해 카메라 전환 시 부드러운 화면 전환

intunknown.tistory.com

6. 문

문은 처음에 한쪽으로만 열리는 문, 양쪽으로 열리는 문, 물리가 적용되는 문 이렇게 3종류를 만들었습니다.

처음에 이 프로젝트를 시작하면서 열쇠를 숨겨놓고 찾아서 탈출하는 쪽이 공포게임에서 흔한 종류라고 생각했습니다.

그래서 열쇠를 찾고 탈출할때 상호작용없이 물리적으로 문을 여는 것 보다 상호작용을 통해 문을 여는쪽이 나중에 더 좋다고 생각해서 다음 방법을 선택했습니다.

Enemy가 플레이어를 추적할 수 있도록 하기 위해 Can Ever Affect Navigation 설정을 False로 설정하고, Overlap함수를 이용해 Enmey가 문의 Collision에 접근하면 열리고 Collision을 벗어나면 문이 닫히도록 만들었습니다.

7. 분위기

깜빡이는 조명

SetTimer함수를 이용해 Delay시간후 Intensity를 변경해 깜빡이는 조명을 구현했습니다.

BGM

오브젝트 하나에 BGM을 위한 Sound를 넣었습니다.

8. Attribute.

HP System.

HP는 피해, 회복, UI모두 구현했지만 잡히면 죽는 몬스터 하나만 구현해서 사실상 쓰이지는 않습니다.

Stamina System.

걷기와 달리기가 존재해서 달리기를 하면 스태미너가 줄어들고, 일정시간 달리지 않으면 스태미너를 조금씩 회복합니다.

Battery System.

손전등이 존재해서 손전등을 사용하면 배터리가 소모되고, 소모된 배터리는 "배터리"아이템을 이용해 회복가능합니다.

9. Enemy

1. Behavior tree를 이용해 Enemy의 행동을 구현했습니다.

2. 이동은 이동 가능한 위치중 랜덤한 위치로 이동합니다.

3. 이동하는 중에 플레이어를 발견하면 특정한 소리를 내며 플레이어를 쫒아옵니다.

4. 플레이어는 Locker에 숨어서 회피할 수 있으며, Enemy 시야에서 Locker에 숨으면 발각되어 게임이 종료됩니다.

5. 플레이어를 인지한 경우 고개를 플레이어를 향해 돌립니다.

6. 플레이어를 놓친 경우 놓친 위치의 근처에서 약 3번정도 찾아보고 다시 플레이어를 찾기위해 배회합니다.

게임 테스트 영상입니다.

https://youtu.be/CH1fWj39H3Q?si=P_lkaf7gFQVpZTmI

언리얼 인벤토리 플러그인 C++

추향 — Sun, 8 Dec 2024 07:06:06 +0900

언리얼 인벤토리 플러그인

심심해서 만드는 중인 인벤토리 플러그인입니다.

C++로 제작하였고, 거의 다 만들었지만 아직 미완입니다.

앞으로 추가하려고 생각하고 있는것.

1. QuickSlot 키보드로 사용할 수 있도록 하기.

2. 장비창 부분 추가.

3. 아이템 사용을 EffectActorClass를 추가해서 사용.

4. 인벤토리 드래그 드롭으로 이동.

완성한 부분.

1. 아이템 저장(Stack가능한 아이템, Stack불가능한 아이템.)

2. 아이템 버리기.

3. 아이템 사용.

4. 아이템 위치 변경(Swap)

5. 아이템 툴팁.

6. QuickSlot 구현.

7. UI 구현(장비창, 인벤창, QuickSlot)

8. ItemBase, ItemActor 구현.(ItemBase는 아이템 정보 저장소 같은 느낌.)

코드 압축.

UI에 사용한 이미지를 뺀 코드.

https://github.com/ykarr/inventorysystemPlugin

GitHub - ykarr/inventorysystemPlugin: Unreal inventory system Plugin

Unreal inventory system Plugin. Contribute to ykarr/inventorysystemPlugin development by creating an account on GitHub.

github.com

실행 결과.

3인칭 튜토리얼에 추가해서 실행한 결과.

https://youtu.be/DjtFztG-yOs

언리얼 절차적 던전 생성

추향 — Mon, 18 Nov 2024 18:26:38 +0900

던전 생성

언리얼에서 절차적으로 던전을 생성하기 위해 작성한 코드입니다.

작동은 하지만 미완성입니다.

간단한 설명.

1. Main Room을 생성하고, Arrow List(ChildrenArrow)를 가져옵니다.

2. 'ChildrenArrow'에서 랜덤으로 Arrow를 선택합니다.

3. 선택한 Arrow의 위치에 Room을 스폰합니다.

4 스폰된 방이 겹치는지 확인합니다:

4.1 충돌이 발생하면 방을 삭제하고 다른 Arrow로 시도합니다.

4.2 충돌이 발생하지 않으면 방을 유지합니다.

5. Room생성에 성공하면 Room의 Arrow를 'ChildrenArrow'에 추가합니다.

이렇게 Room Num을 만족하거나 Arrow없어질 때까지 3-5의 과정을 반복합니다.

실행

실행한 결과는 다음과 같습니다.

방은 두개만 넣어서 실행했습니다.

https://youtu.be/xYDS74XW1Aw

주요 코드.

Generator Room.h

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

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

class ARoom;
class ACorridor;

UCLASS()
class ESCAPE_API AEscapeMapGenerator : public AActor
{
	GENERATED_BODY()
public:	
    UPROPERTY(EditAnywhere, Category = "Dungeon Settings")
    int32 RoomNum = 30;
protected:
	AEscapeMapGenerator();
	virtual void BeginPlay() override;
    TArray<USceneComponent*> ChildrenArrow;
    void GenerateDungeon();
    void SpawnNextRoom(FVector SpawnLoc, FRotator SpawnRot, const TSubclassOf<ARoom>& InRoomClass);
    UPROPERTY(EditAnywhere, Category = "Dungeon Settings")
    TArray<ARoom*> Rooms;
    UPROPERTY(EditAnywhere, Category = "Dungeon Settings")
    TArray<ACorridor*> Corridors;
    UPROPERTY(EditAnywhere, Category = "Dungeon Settings")
	TSubclassOf<ARoom> MainRoomClass;
    UPROPERTY(EditAnywhere, Category = "Dungeon Settings")
    TArray<TSubclassOf<ARoom>> RoomClasses;
private:
    FTimerHandle RoomSpawnDelay;
    int32 CurrentRoomCount=0;
};

Generator Room.cpp

// Fill out your copyright notice in the Description page of Project Settings.
#include "MapGen/EscapeMapGenerator.h"
//구성요소.
#include "MapGen/Room.h"
#include "MapGen/Corridor.h"

#include "Kismet\KismetMathLibrary.h"
#include "Kismet/KismetSystemLibrary.h"
//Component
#include "Components/BoxComponent.h"
//Debug용 커스텀 코드.
#include "DrawDebugHelpers.h"
#include "CustomDebugHelper.h"
// Sets default values
AEscapeMapGenerator::AEscapeMapGenerator()
{
	PrimaryActorTick.bCanEverTick = false;
}
void AEscapeMapGenerator::BeginPlay()
{
	Super::BeginPlay();
	GenerateDungeon();
}
void AEscapeMapGenerator::GenerateDungeon()
{
	//Spawn MainRoom
	if (RoomNum>0) {
		SpawnNextRoom(FVector::ZeroVector, FRotator::ZeroRotator, MainRoomClass);
		CurrentRoomCount = 1;
		//Spawn Other Room
		GetWorld()->GetTimerManager().ClearTimer(RoomSpawnDelay);
		GetWorld()->GetTimerManager().SetTimer(RoomSpawnDelay, FTimerDelegate::CreateLambda([this]() {
			if (CurrentRoomCount < RoomNum && ChildrenArrow.Num() > 0) {
				int32 RandomClassIndex = FMath::RandRange(0, RoomClasses.Num() - 1);
				int32 RandomIndex = FMath::RandRange(0, ChildrenArrow.Num() - 1);
				USceneComponent* SelectArrow = ChildrenArrow[RandomIndex];
				ChildrenArrow.RemoveAt(RandomIndex); // 사용된 Arrow를 제거
				SpawnNextRoom(SelectArrow->GetComponentLocation(), SelectArrow->GetComponentRotation(), RoomClasses[RandomClassIndex]);
			}
			else {
				Debug::Print("End_Generator");
				Debug::Print(FString::FormatAsNumber(ChildrenArrow.Num()));

				GetWorld()->GetTimerManager().ClearTimer(RoomSpawnDelay);
			}
		}), 0.1f, true);
	}
}
void AEscapeMapGenerator::SpawnNextRoom(FVector SpawnLoc,FRotator SpawnRot,const TSubclassOf<ARoom>& InRoomClass)
{
	FActorSpawnParameters SpawnParams;
	SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
	//Spawn
	ARoom* RoomActor = GetWorld()->SpawnActor<ARoom>(InRoomClass, SpawnLoc, SpawnRot, SpawnParams);
	TArray<AActor*> OverlappingActors;
	FCollisionQueryParams QueryParams;
	QueryParams.AddIgnoredActor(RoomActor);  // RoomActor는 검사에서 제외됨
	RoomActor->BoxComponent->GetOverlappingActors(OverlappingActors, ARoom::StaticClass());
	OverlappingActors.Remove(RoomActor);
	if (OverlappingActors.Num() > 0)
	{
		Debug::DrawDebugBox(RoomActor->BoxComponent,true);
		RoomActor->Destroy(); return;
	}
	else
	{
		Debug::DrawDebugBox(RoomActor->BoxComponent);
		// 겹침이 없는 경우: Children 업데이트 및 후속 작업 수행
		CurrentRoomCount++;
		TArray<USceneComponent*> NewChildrenArrow;
		RoomActor->ArrowFolder->GetChildrenComponents(false, NewChildrenArrow);
		ChildrenArrow.Append(NewChildrenArrow); return;
	}
}

Room.h

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

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

class UBoxComponent;
class UArrowComponent;
UCLASS()
class ESCAPE_API ARoom : public AActor
{
	GENERATED_BODY()
public:	
	UPROPERTY(EditDefaultsOnly,BlueprintReadOnly)
	USceneComponent* ArrowFolder;
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
	UBoxComponent* BoxComponent;
protected:
	ARoom();
	virtual void BeginPlay() override;
	UPROPERTY(EditDefaultsOnly)
	USceneComponent* GeometryFolder;
	USceneComponent* RootSceneComponent;
	UPROPERTY(EditDefaultsOnly)
	UArrowComponent* ActorArrowComponent;
};

Room.cpp

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

#include "MapGen/Room.h"
#include "Components/BoxComponent.h"
#include "Components/ArrowComponent.h"
// Sets default values
ARoom::ARoom()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = false;
	RootSceneComponent =CreateDefaultSubobject<USceneComponent>(TEXT("RootSceneComponent"));
	SetRootComponent(RootSceneComponent);
	ActorArrowComponent =CreateDefaultSubobject<UArrowComponent>(TEXT("ActorArrowComponent"));
	ActorArrowComponent->SetupAttachment(GetRootComponent());
	GeometryFolder=CreateDefaultSubobject<USceneComponent>(TEXT("GeometryFolder"));
	GeometryFolder->SetupAttachment(GetRootComponent());
	ArrowFolder =CreateDefaultSubobject<USceneComponent>(TEXT("ArrowFolder"));
	ArrowFolder->SetupAttachment(GetRootComponent());
	BoxComponent=CreateDefaultSubobject<UBoxComponent>(TEXT("BoxComponent"));
	BoxComponent->SetupAttachment(GetRootComponent());
}
void ARoom::BeginPlay()
{
	Super::BeginPlay();
}

Blueprint

이런식으로 Room을 구성합니다.

Arrow의 위치를 기반으로 Room을 생성하기 때문에 문이 위치한 지점에 Arrow를 배치합니다.

Room을 생성하면 0,0,0의 위치에서 생성되기 때문에 이것을 생각해서 Room을 구현합니다.

boxComponent를 이용해 충돌체크를 하기 때문에 방 크기에 맞춰 사용합니다.

Unreal GameplayTag c++

추향 — Mon, 11 Nov 2024 22:41:57 +0900

Unreal GameplayTag

최근 Unreal프로젝트를 만들면서 GameplayAbility를 사용하면서 GameplayTag를 많이 사용해 보았다.

그러면서 에디터 내에서 태그를 추가하고 관리하는 방법이 아닌, 따로 파일을 만들어서 코드 상태로 태그를 선언하는 방법을 사용해보았다.

따로 에디터 내에서 태그를 추가하는 방식이 아닌, 파일을 만들어서 GameplayTag를 추가하고 관리하는 방식이 C++에서 태그를 사용할 때 꽤 편하다는 것을 느낄 수 있었다.

1. 컴파일 타임에 확인할 수 있어 잘못된 태그를 쉽게 찾아낼 수 있었다.

2. 자동완성 기능을 사용해 오타 없이 빠르게 작성해서 사용할 수 있었다.

이 외에도 장점이 더 있지만, 개인적으로는 이것들이 가장 크게 느껴졌다.

개인적으로 이렇게 느꼈다는 것이고, 이 글에서는 간단한 소개와 사용하는 방법에 대한 내용을 작성할 것이다.

1. 컴파일 타임에 확인이 가능해서 잘못된 태그를 찾아내기 편하다.

에디터에서 추가한다면 실행하기 전까지 오류가 있는지 알 수 없지만, 이건 잘못 작성하면 애초에 컴파일 및 빌드가 안돼서 실행할 수 없다.

그런데 어차피 자동완성 켜놓으면 잘못쓰기가 힘들다.

2. 자동완성 기능을 사용해 오타 없이 빠르게 작성해서 사용할 수 있다.

다음이 보통 에디터에서 추가한 태그를 가져오는 방식이다.

길고 FName형식이라 태그 이름에 오타가 생겨도 알려주지 않는다.

게임은 정상적으로? 실행은 되겠지만 해당 태그에 오타가 있다면 해당 태그를 사용하는 기능이 작동하지 않을 것이다.

FGameplayTag::RequestGameplayTag(FName("Player.State.FinishAttack"))

다음이 파일을 만들어서 관리하는 방식이다.

헤더파일만 추가하고 비슷하게 입력하면 다른 것들처럼 적당히 알아서 자동완성 시켜준다.

물론 틀리면 컴파일이 안된다.

BladeGameplayTags::Shared_Event_HitReact

사용하기.

build.cs에 GameplayTags모듈을 추가한다.

1. GameplayTags 파일 추가하기.

먼저 아무것도 상속받지 않는 C++클래스를 생성한다.

(아무거나 생성하고 헤더파일을 지워도 된다.)

다 지웠으면 NativeGameplayTags.h를 include 해주고 아래의 예시처럼 사용하면 된다.

//header
#pragma once
#include "NativeGameplayTags.h"

namespace BladeGameplayTags {
	/** Input **/
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Move);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Look);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Jump);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_EquipSword);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_UnEquipSword);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_LightAttack_Sword);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_HeavyAttack_Sword);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Roll);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_SwitchTarget);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_MustBeHeld);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_MustBeHeld_Block);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Toggleable);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Toggleable_TargetLock);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_Toggleable_Rage);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_SpecialWeaponAbility_Light);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_SpecialWeaponAbility_Heavy);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_SpecialWeaponAbility_3);
	BLADE_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(InputTag_PickUp_Potions);
}

#include "BladeGameplayTags.h"
namespace BladeGameplayTags {
	/** Input **/
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Move, "InputTag.Move");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Look, "InputTag.Look");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Jump, "InputTag.Jump");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_EquipSword, "InputTag.EquipSword");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_UnEquipSword, "InputTag.UnEquipSword");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_LightAttack_Sword, "InputTag.LightAttack.Sword");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_HeavyAttack_Sword, "InputTag.HeavyAttack.Sword");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Roll, "InputTag.Roll");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_SwitchTarget, "InputTag.SwitchTarget");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_MustBeHeld, "InputTag.MustBeHeld");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_MustBeHeld_Block, "InputTag.MustBeHeld.Block");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Toggleable, "InputTag.Toggleable");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Toggleable_TargetLock, "InputTag.Toggleable.TargetLock");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_Toggleable_Rage, "InputTag.Toggleable.Rage");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_SpecialWeaponAbility_Light, "InputTag.SpecialWeaponAbility.Light");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_SpecialWeaponAbility_Heavy, "InputTag.SpecialWeaponAbility.Heavy");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_SpecialWeaponAbility_3, "InputTag.SpecialWeaponAbility.3");
	UE_DEFINE_GAMEPLAY_TAG(InputTag_PickUp_Potions, "InputTag.PickUp.Potions");
}

코멘트가 필요하다면 COMMENT가 붙은 것을 사용하면 된다.

NativeGameplayTags.h 에서 복붙하면 된다.

2. GameplayTags 사용하기.

사용하는 방법은 간단하다.

추가한 파일을 include 하고, GameplayTag를 선언한 네임스페이스를 통해 태그를 불러와 사용하면 됩니다.

(아래 사진 참고.)

플러그인 모듈 설정으로 인한 블루프린트 함수 노출 문제

추향 — Sun, 10 Nov 2024 19:51:51 +0900

문제발생.

언리얼에서 플러그인을 제작하면서 플러그인 쪽에서 선언한 함수가 프로젝트에서 블루프린트로 호출했을 때 노출되지 않는 문제가 발생했습니다. 이 부분은 오류가 아니었고, 플러그인에 대해 잘 몰랐던 내용이라 해결방법을 찾아내기 어려웠습니다.

해결방법 찾는중.

UFUNCTION(BlueprintCallalbe) 설정을 했음에도 함수가 노출되지 않는 것을 보고 당황했습니다.

프로젝트 안에 비슷하게 만들어서 확인해 보니 잘 되는것을 확인했고, 이로 인해 플러그인 문제라는 것은 알았지만 해결방법을 몰라서 열심히 삽질을 시작했습니다.

UCLASS에 타입 설정을 해보기도 하고, 빌드쪽 문제인가 싶어 Binaries, Intermediate, Saved, sln (플러그인쪽도 포함) 삭제한 후 다시 빌드해보는등 이것말고도 한참 열심히 삽질을 해보다가 해결방법을 찾았습니다.

해결방법.

문제의 원인은 플러그인 모듈의 Type설정이었습니다.

아무래도 플러그인 쪽을 많이 만져보지 않다 보니 이 부분이 문제가 될 줄은 몰랐습니다.

생성한 플러그인의 Type이 기본적으로 Editor로 설정되어있었는데 이게 문제였습니다.

모듈의 Type을 Runtime으로 변경하니 잘 동작했습니다.

수정한 플러그인(.uplugin)

독거미 키보드 먹통 해결

추향 — Sat, 9 Nov 2024 23:35:16 +0900

키보드 증상.

뭔가를 잘못 눌렀는지 갑자기 키보드 입력이 먹통이 되는 문제가 발생했습니다.

키보드를 소프트웨어로 리셋해도 백라이트만 초기화되고, 키 입력은 여전히 작동하지 않았습니다.

확인을 위해 다른 컴퓨터에 연결해보니 다른 컴퓨터에서도 키 입력은 작동하지 않았습니다.

다른 키보드를 연결해보니 정상적으로 작동하는 것을 확인하고 키보드의 문제임을 확신했습니다.

예상원인.

키보드 소프트웨어를 설정하다가 펌웨어 버튼을 눌러봤는데 이 부분에서 꼬인 것이 아닐까 싶습니다.

고치기 위해 필요한 준비물.

펌웨어를 재설치해볼 겁니다.

1. 펌웨어

2. 펌웨어를 다운받고 실행받기 위한 컴퓨터.

3. 키보드를 연결해 줄 C 타입 케이블.

4. 독거미 키보드

펌웨어는 여기서 받으면 됩니다.

https://funkeys.co.kr/bbs/board.php?bo_table=download

펀키스 공식 홈페이지

펀키스, Funkeys, 바밀로, 더키, Varmilo, Ducky, 더키 키보드, 바밀로 키보드, 키보드 커스텀, 기계식 키보드, 명품 기계식 키보드, 프리미엄 기계식 키보드, 커스텀 기계식 키보드, Mechanical Keybard, Custom

funkeys.co.kr

위 사이트에서 받은 87pro 유무선 펌웨어입니다.

Aula F87PRO용 펌웨어.exe

2.05MB

해결.

저는 C 타입 케이블을 연결해서 펌웨어를 설치하니까 정상적으로 입력이 되었습니다.

언리얼 플러그인 Online Subsystem Steam

추향 — Fri, 8 Nov 2024 20:53:56 +0900

썸네일

Online Subsystem steam

언리얼 엔진에서 스팀과 연동된 네트워크 기능을 효율적으로 구현할 수 있도록 지원해 주는 플러그인입니다.

이 글에서는 언리얼에서 Steam플러그인을 사용하기 위한 기본적인 설정만을 작성할 겁니다.

플러그인 활성화.

에디터로 들어가서 Online Subsystem steam을 검색해서 플러그인을 활성화해 줍니다.

아래 사진처럼 체크해 주면 에디터가 다시 시작하면서 활성화됩니다.

프로젝트 파일로 들어가서 프로젝트명.Build.cs로 들어갑니다.

여기에 "OnlineSubsystemSteam", "OnlineSubsystem"을 추가합니다.

플러그인 추가로 오류가 생길 수 있으므로 모듈을 추가한 후 에디터로 들어갑니다.

이후 Tools->Refresh Visual Studio를 눌러 project를 Refresh해줍니다.

DefaultEngine.ini

스팀을 사용하기 위해서 DefaultEngine.ini를 수정해줘야 합니다.

자세한 내용은 아래 사이트를 확인하면 됩니다.

https://dev.epicgames.com/documentation/en-us/unreal-engine/online-subsystem-steam-interface-in-unreal-engine?application_version=5.0

DefaultEngine.ini는 프로젝트 파일경로-> Config폴더에서 찾을 수 있습니다.

DefaultEngine.ini에서 다음의 내용을 뒤에 붙여 넣기 하면 됩니다.

[/Script/Engine.GameEngine]
	+NetDriverDefinitions=(DefName="GameNetDriver",DriverClassName="OnlineSubsystemSteam.SteamNetDriver",DriverClassNameFallback="OnlineSubsystemUtils.IpNetDriver")

	[OnlineSubsystem]
	DefaultPlatformService=Steam

	[OnlineSubsystemSteam]
	bEnabled=true
	SteamDevAppId=480

	; If using Sessions
	// 이렇게 되어있는데
    //; bInitServerOnClient=true
	// 세션을 사용하려면 이렇게 해줘야함.
    bInitServerOnClient=true
   
	[/Script/OnlineSubsystemSteam.SteamNetDriver]
	NetConnectionClassName="OnlineSubsystemSteam.SteamNetConnection"

주석으로 적어놓았지만 다시 한번 작성합니다.

언리얼 문서내용을 그대로 복붙하면 세션 생성이 정상적으로 작동하지 않으므로 수정해야 합니다.

bInitServerOnClient=true이걸로.

이렇게 하면 플러그인을 사용하기 위한 기본적인 준비가 완료되었습니다.

네트워크 프로필 유형 초기화되는 경우

추향 — Mon, 4 Nov 2024 07:43:40 +0900

네트워크 프로필 문제.

윈도우에서 네트워크를 이용해 파일 공유를 하려고 설정을 하다가 문제가 발생했습니다.

네트워크 프로필을 개인 네트워크로 변경했는데 재부팅을 하면 공용 네트워크로 다시 돌아가는 문제였습니다.

이로 인해서 컴퓨터를 재부팅하면 해당 컴퓨터에 접속하기 위해서 다시 개인 네트워크 프로필로 바꿔줘야 했습니다.

1. 1 해결방법 배치파일 생성.

인터넷에서 여러 해결방법을 찾아보고 사용했지만 해결이 되지 않았습니다.

뭔가 꼬인것 같은데 컴퓨터를 밀기에는 설치된게 많아서 다시 설치하는 시간이 아까웠습니다.

그래서 임시 방편으로 배치파일과 스케줄러(Scheduler)를 이용해 문제를 해결했습니다.

사용한 배치파일입니다.

배치파일을 안만들어본지 좀 되서 기억이 안나서 GPT한테 시켰습니다.

잘만들어주더라고요.

아래 코드를 텍스트파일에 작성하고 .bat 확장자로 저장합니다.

@echo off
:: Check for administrative privileges
NET SESSION >nul 2>&1
IF %ERRORLEVEL% NEQ 0 (
    PowerShell -Command "Start-Process cmd -Argument '/c %~f0' -Verb RunAs"
    exit /b
)

:: Set the network profile to Private silently
powershell -Command "Set-NetConnectionProfile -NetworkCategory Private -ErrorAction SilentlyContinue"
exit

배치파일도 블로그에 올라가나?

set_network_profile_no_notification.bat

0.00MB

올라가는군요.

눌러보니 잘 작동하지만 누를때마다 관리자 권한으로 실행해야해서 알림이 자꾸 뜹니다.

웬지 시작프로그램에 등록하면 컴퓨터 켤때마다 눌러야될 것 같아서 스케줄러 설정으로 방향을 틀었습니다.

해결방법1.2 스케쥴러 설정.

배치파일은 적당히 안보이는곳에 숨겨두고 Window키+R을 눌러서 실행창을 불러옵니다.

이후 "taskschd.msc"를 입력하고 확인을 눌러줍니다.

이렇게 작업 스케줄러가 나올텐데 오른쪽 메뉴중에 '작업 만들기'를 눌러줍니다.

가장 높은 수준의 권한으로 실행을 체크합니다.

트리거탭에서 새로 만들기.

이후 작업 시작을 로그온할 때로 설정해줍니다.

이제부터 이 스케줄러는 로그온할때마다 실행될겁니다.

이번엔 동작탭에서 새로만들기를 눌러줍니다.

잘 숨겨놓은 배치파일을 선택합니다.

이제 이 스케줄러는 로그온할때마다 네트워크 프로필을 '개인 네트워크'로 변경해줄겁니다.

GameplayAbility Tick 구현 C++

추향 — Tue, 1 Oct 2024 14:32:35 +0900

GameplayAbility Tick

기본적으로 GameplayAbility자체는 Tick을 제공하지 않기 때문에 GameplayAbility에서 Tick을 사용하기 위해서는 추가적인 설정이 필요합니다.

Tick구현 - Ability Task.

GameplayAbility에서 Tick을 사용하기 위해 Ability Task를 이용해 Tick을 구현해서 사용했습니다.

C++로 구현했지만 조금만 수정하면 블루프린트에서도 사용가능합니다.

Ability Task.h

#pragma once

#include "CoreMinimal.h"
#include "Abilities/Tasks/AbilityTask.h"
#include "AbilityTask_ExecuteTaskOnTick.generated.h"

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnAbilityTaskTickDelegate, float, DeltaTime);
/**
 * 
 */
UCLASS()
class BLADE_API UAbilityTask_ExecuteTaskOnTick : public UAbilityTask
{
	GENERATED_BODY()
public:
	UAbilityTask_ExecuteTaskOnTick();
    
	static UAbilityTask_ExecuteTaskOnTick* ExecuteTaskTick(UGameplayAbility* OwningAbility);
	
    //Gameplaytask Interface
	virtual void TickTask(float DeltaTime) override;

	FOnAbilityTaskTickDelegate OnAbilityTaskTick;
};

AbilityTask.cpp

#include "AbilitySystem/AbilityTasks/AbilityTask_ExecuteTaskOnTick.h"

UAbilityTask_ExecuteTaskOnTick::UAbilityTask_ExecuteTaskOnTick()
{
    bTickingTask = true;
}
UAbilityTask_ExecuteTaskOnTick* UAbilityTask_ExecuteTaskOnTick::ExecuteTaskTick(UGameplayAbility* OwningAbility)
{
    UAbilityTask_ExecuteTaskOnTick* Node = NewAbilityTask<UAbilityTask_ExecuteTaskOnTick>(OwningAbility);
    return Node;
}
void UAbilityTask_ExecuteTaskOnTick::TickTask(float DeltaTime)
{
    Super::TickTask(DeltaTime);
    if (ShouldBroadcastAbilityTaskDelegates()) {
        OnAbilityTaskTick.Broadcast(DeltaTime);
    }
    else {
        EndTask();
    }
}

Tick을 필요로 하는 GameplayAbility

위 코드를 보면 아시겠지만 Delegate를 이용한 방법이라 델리게이트를 바인딩하여 사용할 수 있습니다.

TargetLock을 구현하고있는 GameplayAbility를 예시로 보여드리겠습니다.

GameplayAbility.h

#pragma once

#include "CoreMinimal.h"
#include "AbilitySystem/Abilites/BladePlayerGameplayAbility.h"
#include "PlayerTargetLockAbility.generated.h"

class UTargetLockWidget;

UCLASS()
class BLADE_API UPlayerTargetLockAbility : public UBladePlayerGameplayAbility
{
	GENERATED_BODY()
protected:
	virtual void ActivateAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, const FGameplayEventData* TriggerEventData)override;
	virtual void EndAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, bool bReplicateEndAbility, bool bWasCancelled)override;
private:
	void TryLockOnTarget();
	void GetAvailableActorsToTarget();
	void CancelTargetLockAbility();
	void CleanUp();
	void DrawTargetLockWidget();
	void SetTargetLockWidgetLoc();
	/*Tick을 사용하기 위해 바인딩해야하는 함수. UFUNCTION 필수*/
	UFUNCTION()
	void OnTargetLockTick(float DeltaTime);
	/*여기까지*/
	AActor* GetNearestTargetFromAvailableActors(const TArray<AActor*>& InAvailableActors);

	UPROPERTY(EditDefaultsOnly,Category="Target Lock")
	float TraceDistance = 3000.f;
	UPROPERTY(EditDefaultsOnly,Category="Target Lock")
	FVector TraceBoxSize = FVector(3000.f, 3000.f, 300.f);
	UPROPERTY(EditDefaultsOnly,Category="Target Lock")
	TArray<TEnumAsByte<	EObjectTypeQuery> > BoxTraceChannel;
	UPROPERTY(EditDefaultsOnly,Category="Target Lock")
	bool bIsDebugging;
	UPROPERTY()
	TArray<AActor* > AvailableActorsToLock;
	UPROPERTY()
	AActor* CurrentLockActor;
	UPROPERTY(EditDefaultsOnly,Category="Target Lock")
	TSubclassOf<UTargetLockWidget> TargetLockWidgetClass;

	UPROPERTY()
	FVector2D TargetLockBoxSIze = FVector2D::ZeroVector;
	UPROPERTY()
	UTargetLockWidget* TargetLockWidget;
};

GameplayAbility.cpp

ActivateAbility()와 OnTargetLockTick()부분만 보시면 됩니다.

// YunMinSeong. All right reserved. 


#include "AbilitySystem/Abilites/PlayerTargetLockAbility.h"
#include "Characters\BladePlayerCharacter.h"
#include "Kismet\KismetSystemLibrary.h"
#include "Kismet\GameplayStatics.h"
#include "Controllers/BladeController.h"
//Widget
#include "Widgets/TargetLockWidget.h"
#include "Blueprint/WidgetLayoutLibrary.h"
#include "Components/SizeBox.h"

#include "AbilitySystem/AbilityTasks/AbilityTask_ExecuteTaskOnTick.h"
#include "BladeFunctionLibrary.h"
#include "BladeGameplayTags.h"
//Debug
#include "CustomDebugHelper.h"
void UPlayerTargetLockAbility::ActivateAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, const FGameplayEventData* TriggerEventData)
{
	TryLockOnTarget();
	Super::ActivateAbility(Handle, ActorInfo, ActivationInfo, TriggerEventData);
	
	//UAbilityTask_ExecuteTaskOnTick* TickTask=UAbilityTask_ExecuteTaskOnTick::ExecuteTaskOnTick(this);
	UAbilityTask_ExecuteTaskOnTick* TickTask=UAbilityTask_ExecuteTaskOnTick::ExecuteTaskTick(this);
	TickTask->OnAbilityTaskTick.AddDynamic(this, &ThisClass::OnTargetLockTick);
	TickTask->ReadyForActivation();
}
void UPlayerTargetLockAbility::EndAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, bool bReplicateEndAbility, bool bWasCancelled)
{
	CleanUp();
	Super::EndAbility(Handle, ActorInfo, ActivationInfo, bReplicateEndAbility, bWasCancelled);
}
void UPlayerTargetLockAbility::TryLockOnTarget()
{
	GetAvailableActorsToTarget();
	if (AvailableActorsToLock.IsEmpty()) {
		CancelTargetLockAbility();
		return;
	}
	CurrentLockActor=GetNearestTargetFromAvailableActors(AvailableActorsToLock);
	if (CurrentLockActor) {
		DrawTargetLockWidget();
		SetTargetLockWidgetLoc();
	}
	else {
		CancelTargetLockAbility();
	}
}
void UPlayerTargetLockAbility::GetAvailableActorsToTarget()
{
	TArray<FHitResult> BoxTraceHits;
	UKismetSystemLibrary::BoxTraceMultiForObjects(
		GetPlayerCharacterFromActorInfo(),
		GetPlayerCharacterFromActorInfo()->GetActorLocation(),
		GetPlayerCharacterFromActorInfo()->GetActorLocation()+GetPlayerCharacterFromActorInfo()->GetActorForwardVector()* TraceDistance,
		TraceBoxSize/2.f,
		GetPlayerCharacterFromActorInfo()->GetActorForwardVector().ToOrientationRotator(),
		BoxTraceChannel, false,
		TArray<AActor*>(),
		bIsDebugging?EDrawDebugTrace::ForDuration:EDrawDebugTrace::None,
		BoxTraceHits,true
	);
	for (const FHitResult& BoxHit : BoxTraceHits) {
		if (AActor* HitActor=BoxHit.GetActor()) {
			if (HitActor != GetPlayerCharacterFromActorInfo()) {
				AvailableActorsToLock.AddUnique(HitActor);
			}
		}
	}
}
void UPlayerTargetLockAbility::CancelTargetLockAbility()
{
	CancelAbility(GetCurrentAbilitySpecHandle(),GetCurrentActorInfo(),GetCurrentActivationInfo(),true);
}
void UPlayerTargetLockAbility::CleanUp()
{
	AvailableActorsToLock.Empty();
	CurrentLockActor = nullptr;
	if (TargetLockWidget) {
		TargetLockWidget->RemoveFromParent();
	}
	TargetLockWidget = nullptr;
	TargetLockBoxSIze = FVector2D::ZeroVector;
}
void UPlayerTargetLockAbility::DrawTargetLockWidget()
{
	if (!TargetLockWidget) {
		checkf(TargetLockWidgetClass, TEXT("TargetLockWidgetClass is none"));
		TargetLockWidget = CreateWidget<UTargetLockWidget>(GetPlayerControllerFromActorInfo(), TargetLockWidgetClass);
		if (TargetLockWidget) {
			TargetLockWidget->AddToViewport();
		}
	}
}
void UPlayerTargetLockAbility::SetTargetLockWidgetLoc()
{
	if (!TargetLockWidget || !CurrentLockActor) {
		CancelTargetLockAbility();
		return;
	}
	FVector2D ScreenPosition;
	UWidgetLayoutLibrary::ProjectWorldLocationToWidgetPosition(
		GetPlayerControllerFromActorInfo(),
		CurrentLockActor->GetActorLocation(),
		ScreenPosition,
		true
	);
	if (TargetLockBoxSIze == FVector2D::ZeroVector) {
		TargetLockBoxSIze.X = TargetLockWidget->TargetLockBox->GetWidthOverride();
		TargetLockBoxSIze.Y = TargetLockWidget->TargetLockBox->GetHeightOverride();
	}
	ScreenPosition -= TargetLockBoxSIze / 2.f;
	TargetLockWidget->SetPositionInViewport(ScreenPosition,false);
}
void UPlayerTargetLockAbility::OnTargetLockTick(float DeltaTime)
{
	if (!CurrentLockActor|| 
		UBladeFunctionLibrary::NativeDoesActorHaveTag(CurrentLockActor,BladeGameplayTags::Shared_Status_Dead)||
		UBladeFunctionLibrary::NativeDoesActorHaveTag(GetPlayerCharacterFromActorInfo(), BladeGameplayTags::Shared_Status_Dead)) {
		CancelTargetLockAbility();
		return;
	}
	SetTargetLockWidgetLoc();
}
AActor* UPlayerTargetLockAbility::GetNearestTargetFromAvailableActors(const TArray<AActor*>& InAvailableActors)
{
	float ClosestDistance=0.f;
	return UGameplayStatics::FindNearestActor(GetPlayerCharacterFromActorInfo()->GetActorLocation(), InAvailableActors, ClosestDistance);
}

Tick구현 결과.

AbilityTask로 구현한 TargetLock입니다.

Tick을 넣어서 위젯의 위치가 계속 갱신되도록 만들었습니다.

언리얼 슬로우모션

추향 — Sun, 22 Sep 2024 01:27:09 +0900

Unreal SlowMotion

언리얼에서 간단하게 슬로우모션을 구현해보았습니다.

이때 사용한 함수는 게임의 전체 시간 흐름을 조절하는 SetGlobalTimeDilation함수입니다.

이 함수는 게임 전체의 시간 흐름을 자유롭게 조절할 수 있습니다.

코드

2.0f: 시간의 흐름이 두배로 빨라집니다.

1.0f: 기본 흐름. (정상 시간)

0.5f: 시간의 흐름이 절반으로 느려집니다. (슬로우모션.)

0.f: 시간이 완전히 정지됩니다.

아래와 같은 코드를 작성하면 시간의 흐름을 0.5배로, 즉 2배 느리게 만드는 코드인겁니다.

UGameplayStatics::SetGlobalTimeDilation(GetWorld(), 0.5f);

저는 이 기능을 NotifyState에 적용을 해서 애니메이션의 특정 부분만 느려지도록 사용했습니다.

애니메이션의 일부 구간을 아래처럼 만든 NotifyState를 추가하면 해당 부분의 애니메이션을 진행하는 동안 Meshcomponent가 0.2배속으로 재생됩니다.

NotifyState설정.

Notify Begin에서 0.2로 설정하고 End에서 1로 만든 후 애니메이션에 추가했습니다.

실행

실행하면 이렇게 중간에 NotifyState가 적용된 부분이 느려집니다.

Assertion failed: index == TypeIndex 오류 해결.

추향 — Sat, 14 Sep 2024 20:42:34 +0900

오류환경.

최근 윈도우 11에서 언리얼 5.3을 사용하다가 해당 오류에 걸렸습니다.

프로젝트를 빌드했을 때, 빌드가 완료되어도 "Asertion Failed: index== Typeindex ...." 라는 팝업창이 나오면서 프로젝트가 정상적으로 실행되지 않았습니다.

오류 내용.

아래의 메시지를 출력하며 프로젝트가 정상적으로 진행되지 않았습니다.

Assertion failed: Index == TypeIndex [File:E:\Epic Games\UE_5.3\Engine\Source\Runtime\Core\Public\Misc\TVariant.h] [Line: 118] Crash in runnable thread Background Worker #3

제가 해당 언리얼 프로젝트 파일 생성 후 만진것들입니다.

1. 삼인칭 기본 맵 복사.

2. 복사한 맵을 DefaultMap으로 설정.

3. 새로운 GameMode생성(생성만하고 추가작업은 하지 않았습니다.)

방금 만든 프로젝트에서 DefaultMap설정을 건드리고 고장났으니 아무래도 맵이 제일 의심스러웠습니다.

해결방법.

저는 이런 방법으로 해결했습니다.

프로젝트 폴더\Config\DefaultEngine.ini 를 수정했습니다.

파일을 보니까 제가 종료하기 전에 이름을 바꿨던 것 같습니다.

이 부분이 제대로 저장되지 않아서 그것때문에 문제가 생긴 것 같습니다.

GameDefaultMap과 EditorStartupMap에 설정된 파일 경로를 삭제했습니다.

결과.

경로를 삭제했더니 예상대로 프로젝트가 잘 작동했습니다.

그냥 경로 파일 이름을 바꿔줬어도 잘 작동했을 것 같습니다.

The project currently uses the compatibility mode where the Render Graph API is disabled

추향 — Thu, 5 Sep 2024 20:27:11 +0900

The project currently uses the compatibility mode where the Render Graph API is Disabled.

오랜만에 유니티를 사용하기 위해 Unity6을 설치해서 프로젝트를 하나 만들었습니다.

이후 사용하다 보니 다음과 같은 경고 메시지가 나타났습니다.

"The project currently uses compatibility mode where the Render Graph API is disabled. Support for this mode will be removed in future Unity versions. Migrate existing ScriptableRenderPasses to the new RenderGraph API. After the migration, disable the compatibility mode in Edit> Projects Settings> Graphics> Render Graph. UnityEditor.EditorAssemblies:ProcessInitalizeOnLoadMethodAttributes()"

경고 내용.

요약하면, 기존의 ScriptableRenderPasses는 곧 지원이 종료되니, 새로운 RenderGraph API로 Migrate 하라는 내용인 것 같습니다.

대충 채신기술로 갈아타고, 마이그레이션이 완료되면 Compatibility Mode (Render Graph Disabled)를 비활성하라는 것 같습니다.

경고 해결.

뭐...저는 유니티6를 오랜만에 설치했기 때문에 뭐가 바뀐 건지 모르겠지만, 최근에 유니티로 진행한 프로젝트도 없어서 마이그레이션 후 진행하라는 설정을 바로 진행했습니다.

1. Edit> ProjectSettings로 들어갑니다.

2. Project Settings에서 Graphics를 찾고 Render Graph으로 들어갑니다.

누가봐도 경고 메시지인 Compatibility Mode (Render Graph Disabled)를 찾습니다.

"Unity no longer develops or improves the rendering path that does not use Render Graph API. When developing new graphcs features." 빨리 끄라고 온몸으로 소리치고 있네요.

3. Compatibility Mode를 비활성화합니다.

이제 경고 메시지가 보이지 않습니다.

티스토리 블로그에서 스팸 댓글에 대한 고민

추향 — Tue, 3 Sep 2024 21:37:13 +0900

티스토리 블로그에서 스팸 댓글에 대한 고민.

요즘 저는 제 글의 조회수가 맛이 없을 것을 알면서도 글을 작성하고 있습니다.

간단한 주제에 대한 글이기도 하고, 이런 글들이 나중에 저나 다른 사람들에게 도움이 될 수 있기 때문에, 생각날 때마다 블로그에 글을 작성하고 있습니다.

스팸 댓글.

하지만, 언제부턴가 블로그에 매크로로 작성된 것으로 보이는 스팸 댓글이 달리기 시작했습니다.

처음에는 댓글이 달린다는 사실에 기분이 좋았지만, 누가 봐도 스팸 댓글이라 기분이 씁쓸해졌습니다.

방문자가 별로 없을 거라는 사실을 알면서도 글을 쓰기 때문에 댓글이 많이 달리지 않을 거라는 사실을 알지만, 알림이 올 때마다 기대하게 되는 것은 어쩔 수 없는 것 같습니다.

그런데 이 스팸댓글들이 요즘 그 기대를 무너뜨리고 있네요.

제 설램 돌려놓으세요.

스팸댓글 문제.

오늘만 해도 하나의 글에 댓글이 3개나 달렸습니다.

통계를 보면 해당 글은 조회수는 1에 불과합니다. 이것도 제가 들어갔는지 어떤 분이 검색했는지는 기억이 안 나는데, 티스토리 오류로 통계가 제대로 안 잡혔다고 해도, 이 사람들이 제 글에 관심이 없다는 것은 분명합니다.

글을 읽고 있는 여러분을 걸 수도 있을만큼 99퍼센트 확신합니다. (거 혹시 모르니까 저는 못 걸고요.)

조회수가 1인 글에 3개의 댓글이라니, 아무리 생각해도 댓글 가성비가 좋은 거 같아요.

티스토리에서 댓글이란?

사실 티스토리에서는 예전부터 댓글이 큰 의미를 가지지 않았습니다.

그래서, 스팸 댓글을 달고 다니는 분들을 보면서 의문이 생기기도 합니다.

제가 알기로는 누군가 댓글로 도움이 되었다고 말해주면 좀 더 글을 쓴 보람이 있고 딱 그 정도였습니다.

물론 지금도 티스토리에서 댓글 기능이 그 이상의 특별한 의미가 있다고 생각하지는 않습니다.

하지만, 최근 스팸 댓글을 몇 번 받고 나니 생각이 바뀌었습니다.

방문자 수조차 늘지 않는 댓글... 굳이 댓글이 있어야 하나..?

스팸 댓글을 막기 위한 노력.

그래도 가끔씩 무언가를 물어보시는 분들, 제 실수를 잡아주시는 분들, 감사 인사를 해주시는 분들 덕분에 보람을 느낄 수 있어 댓글을 완전히 막지는 않았습니다.

대신, 스팸 댓글로 인한 불쾌감을 조금이라도 줄이기 위해 다음과 같은 조치를 취했습니다.

1. 댓글 작성 제한.

댓글 작성은 로그인한 사용자만 가능하도록 설정했습니다.

2. 스팸 댓글 휴지통 보내기 설정.

스팸 댓글 휴지통 보내기를 사용하도록 설정했습니다.

AI가 알아서 스팸 댓글이면 휴지통으로 보내더군요.

다만, 이 경우 알림이 댓글 알림, 쓰레기통 알림 이렇게 두 번 울려서 조금 그렇긴 합니다.

비밀댓글로 달아도 안 막아지는 것 같더라고요.

안 그래도 조회수 안 나오는데 최근에 글도 안 읽고 이상한 댓글만 달고 가는 사람들이 많더라고요.

거 안 읽었으면 안 읽은 거지, 읽지도 않고 읽은 척 댓글 쓰고 가는 것이 눈에 보여서 글을 썻습니다.

언리얼 게임 종료 구현하기 c++

추향 — Mon, 2 Sep 2024 23:48:15 +0900

언리얼 게임 종료 구현하기 c++

게임을 하다 보면 반드시 있어야 할 것 중 하나가 종료 버튼입니다.

이 글에서는 모든 게임에서 필수적인 요소인 게임 종료를 언리얼엔진의 'UKismetSystemLibrary'에서 제공하는 'QuitGame'함수를 사용해 c++에서 게임 종료를 구현해 보겠습니다.

UKismetSystemLibrary.

'UKismetSystemLibrary'클래스는 게임 플레이, 하드웨어 정보, 월드 관리 등 다양한 시스템 관련 기능을 제공하는 유틸리티 클래스입니다. 이 클래스를 통해 언리얼 엔진에서 게임 종료(QuitGame), 타이머 설정(Delay), 객체 유효성 검사(IsValid), 디버그 메시지(PrintString) 등 여러 작업을 손쉽게 처리할 수 있습니다.

이 클래스는 주로 블루프린트에서 사용되던 기능을 C++ 코드에서도 쉽게 사용할 수 있도록 도와줍니다.

UKismetSystemLibrary::QuitGame 함수.

'UKismetSystemLibrary'클래스는 다양한 기능을 제공하지만, 이번 글에서는 게임을 종료하는 데 사용되는 'QuitGame'함수에 집중하겠습니다.

아래 코드는 'UKismetSystemLibary'클래스에서 'QuitGame'함수만 가져왔습니다.

void UKismetSystemLibrary::QuitGame(const UObject* WorldContextObject, class APlayerController* SpecificPlayer, TEnumAsByte<EQuitPreference::Type> QuitPreference, bool bIgnorePlatformRestrictions)
{
	APlayerController* TargetPC = SpecificPlayer ? SpecificPlayer : UGameplayStatics::GetPlayerController(WorldContextObject, 0);
	if( TargetPC )
	{
		if ( QuitPreference == EQuitPreference::Background)
		{
			TargetPC->ConsoleCommand("quit background");
		}
		else
		{
			if (bIgnorePlatformRestrictions)
			{
				TargetPC->ConsoleCommand("quit force");
			}
			else
			{
				TargetPC->ConsoleCommand("quit");
			}
		}
	}
}

'QuitGame' 함수의 주요 매개변수에 대한 설명.

1. WorldContextObejct : 함수가 실행될 월드 정보를 제공하며, 일반적으로 GetWorld()를 사용합니다

2. SpecificPlayer : 종료할 플레이어 컨트롤러를 지정할 대 사용합니다.

3. QuitPreference : 게임 종료할지 또는 백그라운드로 전환할지 결정합니다.

4. bIgnorePlatformRestrictions : 'true'로 설정하면 플랫폼 제한을 무시하고 게임을 강제로 종료합니다. 'false'로 설정하면 플랫폼 제약을 따르고 일반적인 종료 절차를 수행합니다.

게임 종료 예제.

아래 InputMappingContext를 보면 아시겠지만 Space Bar를 누르면 게임이 종료되도록 만들었습니다.

Pawn.h (헤더 파일)

아래는 'UKismetSystemLibrary::QuitGame' 함수를 사용하여 게임을 종료하도록 구현한 예제코드의 헤더파일입니다.

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

#pragma once

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

class UInputAction;
class UInputMappingContext;
class UCameraComponent;
UCLASS()
class MINIGAME_API AGameTestCharacter : public ACharacter
{
	GENERATED_BODY()

protected:
	AGameTestCharacter();
	virtual void BeginPlay() override;
	virtual void Tick(float DeltaTime) override;
	
	UPROPERTY(EditDefaultsOnly)
	TObjectPtr<UStaticMeshComponent> BodyMesh;
	UPROPERTY(EditDefaultsOnly)
	TObjectPtr<UCameraComponent> MainCamera;
#pragma region ExitGame
public:
protected:
	UPROPERTY()
	TObjectPtr<UInputMappingContext> ExitTestContext;
	UPROPERTY()
	TObjectPtr<UInputAction> ExitAction;
private:
	void ExitGame();
#pragma endregion
};

Pawn.cpp (소스 파일)

UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);

매개변수 1. 'GetWorld()'를 사용해 현재 월드에서 게임 종료하도록 했습니다.

매개변수 2. 'nullptr'을 선택했습니다. 모든 플레이어에게 적용됩니다.

(UGameplayStatics::GetPlayerController(WorldContextObject, 0)을 통해 얻을 수 있는 첫 번째 플레이어 컨트롤러)

매개변수 3. 게임을 즉시 종료하기 위해 EQuitPreference::Quit를 선택했습니다.

매개변수 4. 일반적인 종료가 되도록 false를 선택했습니다.

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

#include "Character/GameTestCharacter.h"
//input
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
#include "InputAction.h"
#include "InputMappingContext.h"
//Camera
#include "Camera\CameraComponent.h"
#include "Camera\CameraActor.h"
//유틸리티
#include "Kismet\KismetSystemLibrary.h"

#include "Kismet\GameplayStatics.h"

// Sets default values
AGameTestCharacter::AGameTestCharacter():bToggleCam(1)
{
 	// 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;
	BodyMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("BodyMesh"));
	BodyMesh->SetupAttachment(GetRootComponent());
	SetRootComponent(BodyMesh);
	//메인 카메라.
	MainCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MainCam"));
	MainCamera->SetupAttachment(GetRootComponent());
	//InputSettings
	static ConstructorHelpers::FObjectFinder<UInputMappingContext> FIndTestMappingContext(TEXT("InputMappingContext'/Game/Blueprints/Input/IMC_Test.IMC_Test'"));
	if (FIndTestMappingContext.Succeeded()) {
		ExitTestContext = FIndTestMappingContext.Object;
	}
	static ConstructorHelpers::FObjectFinder<UInputAction> FindTestAction(TEXT("InputAction'/Game/Blueprints/Input/InputAction/Test/IA_TestSpace.IA_TestSpace'"));
	if (FindTestAction.Succeeded()) {
		ExitAction = FindTestAction.Object;
	}
}
// Called when the game starts or when spawned
void AGameTestCharacter::BeginPlay()
{
	Super::BeginPlay();
	UEnhancedInputLocalPlayerSubsystem* SubSystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetWorld()->GetFirstPlayerController()->GetLocalPlayer());
	if (IsValid(SubSystem)) {
		SubSystem->AddMappingContext(ExitTestContext, 0);
	}
	//시작하고 화면을 클릭하지 않아도 키보드 동작이 가능하도록.
	FInputModeGameOnly InputMode;
	GetWorld()->GetFirstPlayerController()->SetInputMode(InputMode);
}
// Called every frame
void AGameTestCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
}
void AGameTestCharacter::ExitGame()
{
	UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);
}
// Called to bind functionality to input
void AGameTestCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
	UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);
	if (IsValid( EnhancedInputComponent)) {
		EnhancedInputComponent->BindAction(ExitAction, ETriggerEvent::Started, this, &AGameTestCharacter::ExitGame);
	}
}

UI부분도 붙여서 같이 올릴까 했는데 어차피 사용 방법 자체는 똑같아서 빼고 올렸습니다.

그래서 그냥 UI사용하는 부분은 나중에 따로 올릴 예정입니다.

언리얼 카메라 시점 변경 c++

추향 — Sat, 31 Aug 2024 00:28:47 +0900

언리얼 카메라 시점 변경 c++

언리얼에서 c++을 이용해 카메라 시점을 변경 하는 방법에 대해 보여주는 글입니다.

이 글에서는 'SetViewTargetWithBlend'함수를 활용해 카메라 전환 시 부드러운 화면 전환을 구현하는 방법을 사용합니다.

Pawn 구성.

먼저 'Character' 클래스에 'CameraComponent'를 하나 추가합니다.

그리고 플레이어가 지정한 키를 누를 때, 레벨에 배치된 'CameraActor'를 찾아 해당 'CameraActor'로 시점을 변경하도록 구현했습니다.

헤더파일(.h)

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

#pragma once

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

class UInputAction;
class UInputMappingContext;
class UCameraComponent;
UCLASS()
class MINIGAME_API AGameTestCharacter : public ACharacter
{
	GENERATED_BODY()

protected:
	AGameTestCharacter();
	virtual void BeginPlay() override;
	virtual void Tick(float DeltaTime) override;
	
	UPROPERTY(EditDefaultsOnly)
	TObjectPtr<UStaticMeshComponent> BodyMesh;
	UPROPERTY(EditDefaultsOnly)
	TObjectPtr<UCameraComponent> MainCamera;

private:
	//카메라 변경을 위한 bool변수.  
	bool bToggleCam;
#pragma region TestPlayerInputSettings
	UPROPERTY()
	TObjectPtr<UInputMappingContext> TestContext;
	UPROPERTY()
	TObjectPtr<UInputAction> SwitchAction;

	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	//input이 들어왔을 때 카메라 변경해줄 함수.
	void SwichCamera();
#pragma endregion
};

cpp파일(.cpp)

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


#include "Character/GameTestCharacter.h"
//input
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
#include "InputAction.h"
#include "InputMappingContext.h"
//Camera
#include "Camera\CameraComponent.h"
#include "Camera\CameraActor.h"

#include "Kismet\GameplayStatics.h"

// Sets default values
AGameTestCharacter::AGameTestCharacter():bToggleCam(1)
{
 	// 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;
	BodyMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("BodyMesh"));
	BodyMesh->SetupAttachment(GetRootComponent());
	SetRootComponent(BodyMesh);
	//메인 카메라.
	MainCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MainCam"));
	MainCamera->SetupAttachment(GetRootComponent());
	//InputSettings
	static ConstructorHelpers::FObjectFinder<UInputMappingContext> FIndTestMappingContext(TEXT("InputMappingContext'/Game/Blueprints/Input/IMC_Test.IMC_Test'"));
	if (FIndTestMappingContext.Succeeded()) {
		TestContext = FIndTestMappingContext.Object;
	}
	static ConstructorHelpers::FObjectFinder<UInputAction> FindTestAction(TEXT("InputAction'/Game/Blueprints/Input/InputAction/Test/IA_TestSpace.IA_TestSpace'"));
	if (FindTestAction.Succeeded()) {
		SwitchAction = FindTestAction.Object;
	}
}
// Called when the game starts or when spawned
void AGameTestCharacter::BeginPlay()
{
	Super::BeginPlay();
	UEnhancedInputLocalPlayerSubsystem* SubSystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetWorld()->GetFirstPlayerController()->GetLocalPlayer());
	if (IsValid(SubSystem)) {
		SubSystem->AddMappingContext(TestContext, 0);
	}
	//시작하고 화면을 클릭하지 않아도 키보드 동작이 가능하도록.
	FInputModeGameOnly InputMode;
	GetWorld()->GetFirstPlayerController()->SetInputMode(InputMode);
}

// Called every frame
void AGameTestCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
}
void AGameTestCharacter::SwichCamera()
{//카메라 변경 토글 함수.
	float BlendTime = 1.f;
	if (bToggleCam) {//bToggleCam이 1인경우 SubCam으로 변경
		//CameraActor를 Level에 하나만 추가해놓은 상태라 GetActorOfClass함수를 사용하면 원하는 카메라가 선택됨.
		AActor* SubCameraActor = UGameplayStatics::GetActorOfClass(GetWorld(), ACameraActor::StaticClass());
		GetWorld()->GetFirstPlayerController()->SetViewTargetWithBlend(SubCameraActor, BlendTime);
	}
	else {
		GetWorld()->GetFirstPlayerController()->SetViewTargetWithBlend(this, BlendTime);
	}
	bToggleCam = !bToggleCam;
}
// Called to bind functionality to input
void AGameTestCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
	UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);
	if (IsValid( EnhancedInputComponent)) {
		EnhancedInputComponent->BindAction(SwitchAction, ETriggerEvent::Started, this, &AGameTestCharacter::SwichCamera);
	}
}

테스트 환경 구성.

GameMode

'GameMode'는 'Default Pawn Class'만 변경했습니다.

Level

카메라 시점 변경만 테스트할 예정이기때문에 Level은 간단하게 구성했습니다.

바닥, Camera Actor ,PlayerStart, SpotLight.만 배치했습니다.

Pawn

위에서 설명한 AGameTestCharacter를 BP로 만들어서 사용합니다.

원뿔 Mesh를 추가하고 카메라 위치만 조절했습니다.

다 만들고 보니까 왜 Character로 만들었는지 모르겠네요.ㅋㅋㅋㅋ

테스트하는 데는 상관없으니까... 넘어가죠?

실행결과.

Space를 누르면 Level에 존재하는 CameraActor를 찾아서 시점이 변경됩니다.

다시 한번 space를 누르면 원래 카메라로 시점이 변경됩니다.

시점변경을 사용한 예시.

아래 동영상은 제가 만들던 공포게임에서 SetViewTargetWithBlend를 사용하여 시점을 변경한 부분입니다.

상자의 자물쇠를 누르면 플레이의 카메라에서 자물쇠의 카메라로 부드럽게 보간하 시점이 변경됩니다.

특정키를 누르면 자물쇠의 카메라에서 다시 플레이어의 카메라로 부드럽게 보간하며 시점이 변경됩니다.

위에서 작성한 코드와 동일한 방식입니다.

새로 추가한 SSD가 보이지 않는 경우

추향 — Wed, 28 Aug 2024 14:53:15 +0900

새로 추가한 SSD가 보이지 않는 경우

컴퓨터에 새로 산 SSD를 장착했을 때 내 PC에서 보이지 않는 경우 활성화시켜주는 방법에 대한 글입니다.

이 글에서는 SSD를 이용해 설명했지만 HDD도 동일합니다.

새로운 SSD 추가

새로운 SSD를 처음 구매하고 컴퓨터에 추가한다면 당황하실 수 있습니다.

처음 구매한 SSD나 HDD는 내 PC에서 보이지 않기 때문입니다.

아래 사진처럼요.(현재 저장장치3개가 연결되어 있지만 2개만 보이는 중)

이 경우 초기화를 진행하지 않아서 보이지 않는 경우가 대부분입니다.

내 PC-> 우클릭-> 추가옵션클릭-> 관리를 눌러줍니다.

디스크 초기화

"컴퓨터 관리"로 들어갔다면 저장소->디스크 관리로 들어갑니다.

아래 사진처럼 디스크 초기화가 나올 겁니다.

(안 나온다면 해당되는 디스크를 찾아서 초기화하세요)

아래 사진을 보면 MBR/GPT라고 선택한 디스크에 사용할 파티션 형식을 선택하라고 합니다.

MBR은 약 2TB(2000GB)가 최대로 인식됩니다.

구형 메인보드를 사용하면서 추가하는 저장장치의 용량이 2TB 이하라면 MBR을 추천드립니다.

GPT는 UEFI부팅이나 2TB를 초과하면 선택했었는데 요즘엔 보통 GPT를 사용합니다.

한 줄 요약: 구형 메인보드 아니면 GPT선택.

디스크 초기화가 끝나면 새 단숨 볼륨을 선택해서 파티션을 만들어주면 됩니다.

단순 볼륨 만들기 마법사가 실행될 텐데 파티션 크기 지정하고, 드라이브 문자 할당하면 끝납니다.

이렇게 하면 새로 추가한 SSD가 내 PC상에서 보이게 됩니다.

iptime 포트 포워딩 (포드 포워드)

추향 — Tue, 27 Aug 2024 23:16:58 +0900

iptime 포트 포워딩 (포트 포워드)

이 글은 iptime 공유기 설정 중에서 포트 포워딩(포트 포워드)에 한 글입니다.

먼저 포트에 대해 간단하게 설명하고, 윈도우 원격 프로그램인 RDP에 사용하는 포트에 대한 설명을 한 뒤, iptime 공유기에서 포트 포워드 설정하는 방법에 대해 작성할 예정입니다.

포트 번호와 포트 포워딩이란?

포트 번호.

포트 번호는 호스트에서 동작하고 있는 서비스를 구분하는 번호입니다.

2바이트 정수로 0~65535까지 사용가능합니다.

포트 포워딩이란?

아이피에는 외부 아이피와 내부 아이피라는 것이 있습니다.

내부아이피는 192.168.xx.xx같은 형태로 되어있는 아이피입니다.

외부에서 pc에 있는 ftp를 접속하기 위해 요청을 보냅니다.

그런데 공유기는 어떤 pc로 연결해줘야 하는지 모르는 상황입니다.

이럴때 외부아이피:포트(21)번을 하면 ftp를 사용할 수 있게 됩니다.(pc2에 접근.)

이런식으로 공유기에 어디로 가야하는지 알려주는 것이 포트포워딩입니다.

설명을 잘못하겠네요.ㅋㅋㅋ 궁금하시면 더 잘 설명해놓으신 분들 많으니 검색해보시는 것을 추천드립니다.

*윈도우10에서 원격을 위해 기본으로 사용하는 포트는 3389입니다.

원격 접속을 위한 포트.

내부에서 원격을 하기 위해서는 그냥 내부 아이피:3389만 입력하면 되었지만 외부에서 원격을 사용하기 위해서는 공유기랑 약속을 해줄 필요가 있습니다.

원격 접속을 위해서는 3389포트를 사용해야 합니다.(포트는 변경 가능합니다.)

위에서 말한 포트포워딩의 예시는 다음과 같습니다.

외부아이피:1111로 공유기에 접근하면 공유기는 원격을 사용할 컴퓨터아이피:3389포트로 연결해줘야해!가 되는 겁니다.

[유용한정보/윈도우] - 윈도우10 원격 데스크톱 연결(RDP)

윈도우10 원격 데스크톱 연결(RDP)

윈도우10 원격 데스크톱 연결(RDP) 안녕하세요. 오늘은 윈도우10 pro에서 원격 데스크톱을 연결하는 방법에 대한 글입니다. 윈도우10 pro에서는 기본 내장된 원격 프로그램으로 원격을 사용할 수 있습니다. 원격..

intunknown.tistory.com

iptime포트포워드 설정.

이제 그럼 포트포워딩을 해보겠습니다.

iptime 공유기에서만 해봤지만 다른 공유기들도 크게 다르지 않을겁니다.

이 글에서는 제가 iptime공유기를 사용하기 때문에 iptime 공유기로 설명하겠습니다.

192.168.0.1을 주소창에 입력해서 공유기 설정으로 들어갑니다.

로그인 해주세요.

관리 도구로 들어갑니다.

고급 설정-->NAT/라우터 관리-->포트 포워드 설정으로 들어갑니다.

새 규칙을 추가해줍니다.

아래 사진을 참고해주세요.

외부에서 3389포트로 접속하면 192.168.0.33의 3389포트로 연결할겁니다.

여기서 만약에 외부 포트만 11111로 바꾼다고 가정하겠습니다.

이후 외부 아이피:11111로 연결하면 192.168.0.33:3389로 연결되는 겁니다.

+추가로 볼만한 내용.

[유용한정보] - 아이피 확인하는 방법

[유용한정보] - 아이피타임 공유기 초기화하는 방법

[유용한정보] - 울트라서프 컴퓨터 아이피 변경 프로그램 최신버전

죄송합니다. 이 pin은 조직의 리소스에 대해 작동하지 않습니다. 해결방법.

추향 — Tue, 27 Aug 2024 19:35:38 +0900

죄송합니다. 이 Pin은 조직의 리소스에 대해 작동하지 않습니다. 해결방법.

"죄송합니다. 이 PIN은 조직의 리소스에 대해 작동하지 않습니다. 문제를 해결하려면 여기를 탭하거나 클릭하세요." 라는 메시지가 나오면서 Windows Hello PIN 옵션을 사용할 수 없을 때, 이를 해결하는 방법에 대한 글입니다.

문제 상황.

PIN을 변경하기 위해 Windows 설정-> 계정 -> 로그인 옵션에 들어갔더니, "죄송합니다. 이 PIN은 조직의 리소스에 대해 작동하지 않습니다. 문제를 해결하려면 여기를 탭하거나 클릭하세요."라는 메시지가 출력되며 PIN을 변경할 수 없게되었습니다.

클릭해보면 이렇게 나옵니다.

해결방법.

해결방법은 간단했습니다.

Windows 설정-> 계정 -> "회사 또는 학교 액세스" 에서 회사 또는 학교 계정 추가부분에 있는 계정을 눌러 연결 끊기 하시면 됩니다.

아래 사진처럼 "계정"을 제거하면 "PIN 변경"이 활성화 됩니다.

이후 필요에 의해 회사나 학교 계정이 필요하시다면 다시 연결하시면 됩니다.

바라쿠다X 펌웨어 업데이트

추향 — Mon, 26 Aug 2024 13:37:55 +0900

바라쿠다X 펌웨어 업데이트.

바라쿠다X 펌웨어 업데이트 방법에 대한 글입니다.

한참 바라쿠다X를 사용하면서 문제가 없어서 펌웨어 업데이트는 생각도 하지 못했습니다.

그런데 보니까 있더라고요. 그래서 한번 설치해봤습니다.

바라쿠다X펌웨어 다운.

아래 사이트에서 바라쿠다X와 나머지 레이저 제품의 펌웨어 업데이트를 받을 수 있습니다.

바라쿠다X의 경우에는 구형과 신형이 있으므로 신형은 Barracuda X(2022)를 받으시면 됩니다.

https://mysupport.razer.com/app/answers/detail/a_id/4166/kw/firmware

Software and Firmware Updates for Razer Peripherals

Software and Firmware Updates for Razer Peripherals Updated: 30-Jul-2024 | Answer ID: 4166 This answer provides software and firmware updates for Razer Peripherals.

mysupport.razer.com

바라쿠다X 펌웨어 업데이트 시작.

펌웨어 설치 방법은 간단합니다.

위에 올려드린 바라쿠다X 펌웨어 다운 주소로 들어갑니다.

이후 RAZER BARRACUDA X 펌웨어 업데이트 프로그램을 다운받습니다.

저는 구형 바라쿠다라 (2022가 아닌 버전) 해당되는 프로그램을 받았습니다.

프로그램을 설치하고 케이블은 연결하니 제 헤드셋 버전은 1.00.09네요.

최신버전이 1.4.0이니까 업데이트를 눌러줍니다.

이런 펌웨어 업데이트에서 항상 나오는 컴퓨터 전원을 끄거나 장치를 제거하지 마십시오.

조금 기다려줍니다.

펌웨어 업데이트 완료.

잠시 기다리면 이렇게 펌웨어 업데이트가 끝납니다!

시간도 오래걸리지 않고 간단하게 업데이트 할 수 있었는데 역시나 달라진것은 느껴지지 않습니다.

이전에 사용하면서 문제를 느끼지 못해서 더 그렇게 느껴지는 것 같습니다.

그래도 혹시 모르니까 다들 펌웨어 올릴 수 있으면 올리는 것을 추천드립니다.

윈도우11 빠른 시작 켜기 옵션

추향 — Fri, 23 Aug 2024 15:39:55 +0900

제목

윈도우11의 빠른 시작 켜기 옵션이 제어판에서 보이지 않는 경우 보이게 하는 방법 대해 다루는 글입니다.

빠른 시작 켜기란?

윈도우8 이후 도입된기능으로 컴퓨터를 종료할 때 hiberfil.sys에 정보를 저장했다가 다음 부팅때 사용해 빠르게 부팅을 시키는 기능입니다.

사실 완전히 종료하는 것은 아니고 최대절전모드 같은겁니다.

빠른 시작 옵션 보이게 하기.

빠른 시작 옵션을 보이게 하는 방법은 간단합니다.

몇가지 명령어만 입력해주면 됩니다.

Windows PowerShell이나 Cmd(명령 프롬프트)를 검색합니다.

PowerShell(관리자 모드)나 Cmd(명령 프롬프트/관리자모드)를 실행합니다.

관리자 모드로 실행된 창에 powercfg -h on을 입력합니다.

powercfg -h on

이후 제어판->전원 옵션.

전원 옵션->전원 단추 작동 설정.

보이지 않던 빠른 시작 켜기 버튼이 활성화 된 것을 확인할 수 있습니다.

이후 방패모양의 "현재 사용할 수 없는 설정 변경"을 누르면 빠른 시작 켜기를 활성/비활성 할 수 있습니다.

배치파일.

관리자 권한으로 실행하고 " 전원 단추 작동 설정"에서 설정해도 됩니다.

fastBootSet.bat

0.00MB

powercfg -h on
control powercfg.cpl

Unreal 생성자에서 리소스 불러오기 C++

추향 — Sun, 18 Aug 2024 23:14:59 +0900

Unreal 생성자에서 리소스 불러오기 C++

이 글은 Unreal Engine에서 ConstructorHelpers를 사용해 생성자에서 특정 리소스를 불러오는 방법에 대한 글입니다.

ConstructorHelpers에 대한 간단한 설명.

ConstructorHelpers 클래스는 C++에서 객체를 생성할 때 리소스를 찾고 로드할 때 사용됩니다.

객체를 생성할 때 사용되므로 생성자에서만 사용가능합니다.

런타임에서 리소스를 로딩하기 위해서는 다른 방법을 사용해야 하고 이 글에서는 다루지 않습니다.

https://dev.epicgames.com/documentation/ko-kr/unreal-engine/gameplay-classes-in-unreal-engine

FClassFinder

FClassFinder는 'ConstructorHelpers'의 헬퍼 클래스로 클래스를 찾기 위해 사용합니다.

아래는 사용 예시 코드입니다.

static ConstructorHelpers::FClassFinder<ACustomCharacter> CustomCharacterClassFinder(TEXT("Blueprint'/Game/PathToYourBlueprint/BP_CustomCharacter.BP_CustomCharacter_C'"));
if (CustomCharacterClassFinder.Succeeded()) {
    TSubclassOf<ACustomCharacter> CustomCharacterClass = CustomCharacterClassFinder.Class;
}

FObjectFinder

'ConstructorHelpers'의 헬퍼 클래스로 오브젝트(머티리얼, 텍스처, 스프라이트 등)를 찾기 위해 사용합니다.

아래는 사용 예시 코드입니다.

1. Material Instance

static ConstructorHelpers::FObjectFinder<UMaterialInstance> MaterialInstanceFinder(TEXT("MaterialInstanceConstant'/Game/PathToYourMaterialInstance/YourMaterialInstance.YourMaterialInstance'"));
if (MaterialInstanceFinder.Succeeded()) {
    UMaterialInstance* MyMaterialInstance = MaterialInstanceFinder.Object;
}

2. Static Mesh

static ConstructorHelpers::FObjectFinder<UStaticMesh> MeshAssetFinder(TEXT("StaticMesh'/Game/PathToYourMesh/YourMesh.YourMesh'"));
if (MeshAssetFinder.Succeeded()) {
    UStaticMesh* MyMesh = MeshAssetFinder.Object;
}

3. Texture

static ConstructorHelpers::FObjectFinder<UTexture2D> TextureAssetFinder(TEXT("Texture2D'/Game/PathToYourTexture/YourTexture.YourTexture'"));
if (TextureAssetFinder.Succeeded()) {
    UTexture2D* MyTexture = TextureAssetFinder.Object;
}

4. Sound

static ConstructorHelpers::FObjectFinder<USoundBase> SoundAssetFinder(TEXT("SoundCue'/Game/PathToYourSound/YourSound.YourSound'"));
if (SoundAssetFinder.Succeeded()) {
    USoundBase* MySound = SoundAssetFinder.Object;
}

언리얼 프로젝트 파일 용량 관리 c++

추향 — Mon, 22 Jul 2024 10:39:46 +0900

언리얼 프로젝트 파일 용량관리

이 글은 언리얼 프로젝트 파일 용량관리에 대한 글을 다루고 있습니다.

C++이랑 Blueprint프로젝트는 지우면 안 되는 파일 등이 살짝 다르긴 해서 제목에 C++을 붙였습니다.

지우면 안 되는 파일.

.uproject파일 : 언리얼 에디터를 구동시키는 연결파일.

Source폴더 : C++전용, 소스코드 등이 들어있음.

Config폴더 : 언리얼 프로젝트의 환경설정을 저장하는 파일.

Content폴더 : 프로젝트에서 사용되는 모든 에셋을 포함하는 폴더.

Plugins폴더 : 엔진에서 제공해 주는 플러그인이 아닌 다른 외부 플러그인.

지워도 되는 파일.

이부분은 프로젝트 파일을 다시 빌드하면 생성되므로 삭제해도 상관없음.

.sln파일 -> visual studio solution파일 .uproject파일로 다시 생성가능.

.vs폴더

Binaries폴더

Build폴더

Intermediate폴더

DerivedDataCache폴더

지워도 되긴 하지만 지우지 않는 것이 좋은 파일.

Saved폴더 : 프로젝트 작업 중 생성되는 임시 파일 및 저장된 데이터(로그 파일, 임시 캐시 파일, 백업파일, 스크린샷 등)

배치파일.

프로젝트 파일을 여러개 만들었더니 용량을 좀 많이먹더라고여.

사용하지 않고 용량만 많이 차지하는데 일일이 지우기 귀찮아서 배치파일로 만들었습니다.

원하는 이름.bat으로 저장.

Saved를 넣거나 빼거나.

rmdir Build /s /q
rmdir Intermediate /s /q
rmdir .vs /s /q
rmdir DerivedDataCache /s /q
rmdir Saved /s /q
del *.sln

gitignore도 비슷합니다.

필요없는파일을 무시하도록 설정하면됩니다.

Unreal에서 새로운 충돌 채널 추가

추향 — Mon, 22 Jul 2024 09:49:56 +0900

Unreal에서 새로운 충돌 채널 추가

이 글은 Unreal에서 새로운 충돌 채널을 추가하는 방법에 대한 글입니다.

Unreal Editor에서 새로운 Trace Channel 추가

Unreal Editor에서 Edit -> ProjectSettings로 들어갑니다.

Project Settings에서 Engine/Collision으로 들어갑니다.

Engine/Collision으로 들어왔다면 Trace Channels를 추가합니다.

아래 사진은 예시입니다.

저는 Test채널을 추가했습니다.

(Default Response는 Ingnore로 설정했습니다만...이 부분은 필요에 맞게 설정하시면 됩니다. )

추가후.

새로 추가한 충돌 채널 사용 예시 C++

Tick에서 SphereTraceSingle을 사용했습니다.

void ATestWorldCharacter::Tick(float DeltaSeconds)
{
	Super::Tick(DeltaSeconds);
	FVector CamFwdVec = FollowCamera->GetForwardVector();
	FVector CamLoc = FollowCamera->GetComponentLocation();
	FVector StartVec =(CamFwdVec * 800) + CamLoc;
	FVector EndVec = (CamFwdVec * 1500) + CamLoc;
	FHitResult HitResult;
	/*Unreal 에디터에서 설정한 Trace Channel*/
	ETraceTypeQuery TestTraceTarget = UEngineTypes::ConvertToTraceType(ECollisionChannel::ECC_GameTraceChannel1);
	bool IsHit =
		UKismetSystemLibrary::SphereTraceSingle(
		GetWorld(), 
		StartVec/*시작위치*/,
		EndVec/*끝위치*/,
		330.f/*Radius*/,
		TestTraceTarget/*Trace Channel*/,
		false, 
		TArray<AActor*>(), 
		EDrawDebugTrace::ForOneFrame, 
		HitResult/*Hit결과*/,
		true/*자기자신 무시 여부*/);
	if (IsHit) {
		DrawDebugSphere(
        GetWorld(), 
        HitResult.ImpactPoint, 
        30.f, 
        30.f, 
        FColor::Green, 
        false, 
        1);
	}
}

큐브 하나만 선택해서 새로 추가한 Collision Channel(여기서는 Test라는 이름을 가진 채널)을 Block으로 바꿔주었습니다.

실행결과

Test Channel을 Block으로 설정된 큐브를 제외한 나머지는 Object들은 Sphere Trace에 걸리지 않습니다.

DefaultEngine.ini

프로젝트 파일 -> Config -> DefaultEngine.ini

'DefaultEngine.ini' 파일은 Unreal Engine의 다양한 설정을 저장하는 파일입니다.

이중에 ECC_GameTraceChannel은 위에서 추가했던 Trace Channel을 의미합니다.

아래 사진에서 ECC_GameTraceChannel1은 아까 예시로 추가했던 Test Channel인 것을 확인할 수 있습니다.

Unreal 파쿠르(vault) c++

추향 — Tue, 11 Jun 2024 08:13:26 +0900

Unreal 파쿠르(vault) c++

이 글은 Unreal에서 파쿠르(vault)를 C++로 제가 이런식으로 구현했다 라는 것을 기록으로 남기기 위한 글입니다.

해당글에서는 언리얼의 Motion Warping을 사용해 만들었습니다.

모션워핑 활성화 및 애니메이션 구하기.

언리얼에서 Motion Warping은 캐릭터의 루트 모션이 타겟과 일치하도록 동적으로 정렬하는 기능입니다.

https://dev.epicgames.com/documentation/en-us/unreal-engine/API/Plugins/MotionWarping/UMotionWarpingComponent?application_version=5.1

이 기능을 사용하기 위해서 모션워핑 플러그인을 활성화 해야되고, 애니메이션이 루트 모션이어야 합니다.

Mixamo같은데서 이런 애니메이션은 구하기 쉬우니 따로 올리지는 않겠습니다.

에디터->Edit->Plugin으로 가서 Motion Warping을 아래 사진처럼 활성화.

프로젝트이름.Build.cs로 가서 "MotionWarping"을 추가합니다.

애니메이션 설정.

Animation montage에 파쿠르 애니메이션을 추가하고, Add Notify State에서 Motion Warping을 추가해줍니다.

이런식으로 설정했습니다.

1.  WarpTargetName= ValutStart
	Warp Translation= true
    ignore ZAxis=false
2. WarpTargetName= ValutMiddle
	Warp Translation= true
    ignore ZAxis=true
3. WarpTargetName= VaultEnd
	Warp Translation= true
    ignore ZAxis=false

파쿠르를 시작할때와 끝날때는 z축이 바뀔 수 있으므로 Ignore ZAxis를 false로 설정해주었습니다.

아래 사진에 Warp Rotation true도 있긴한데 이건 필요 없을거같네요.

Vaulting C++

모션워핑을 적용하기 위해 Vault를 사용할 캐릭터에 아래와같이 Motion Warping Component를 만들었습니다.

(변수 선언 생략)

#include "MotionWarpingComponent.h"

생성자{
	MotionWarpComponent = CreateDefaultSubobject<UMotionWarpingComponent>(TEXT("MotionWarpComponent"));
}

Vault구현.

#pragma region Vault
void ATroyCharacter::Vault()
{
	bIsCanWarp = false;
	FVector LocTmp = GetActorLocation();
	FVector LocEnd = GetActorForwardVector() * 180;
	for (int32 i = 0; i < 3; i++) {
		LocTmp = LocTmp + (FVector(0, 0, 30) * i);
		FHitResult FirstHit;
		TArray<AActor*> IgnoreActor;
		IgnoreActor.Add(this);
		IgnoreActor.Add(EquippedWeapon);
		//UKismetSystemLibrary::SphereTraceSingle(GetWorld(), LocTmp, LocEnd+LocTmp,5.f,ETraceTypeQuery::TraceTypeQuery1,false, IgnoreActor,EDrawDebugTrace::ForDuration, Hit,true);
		if (UKismetSystemLibrary::SphereTraceSingle(GetWorld(), LocTmp, LocEnd + LocTmp, 10.f, ETraceTypeQuery::TraceTypeQuery1, false, IgnoreActor, EDrawDebugTrace::None, FirstHit, true)) {
			FHitResult SecondHit;
			FVector Start = FirstHit.Location + GetActorForwardVector();
			for (int32 j = 0; j < 5; j++) {
				FVector NextLoc = GetActorForwardVector() * j * 50;
				if (UKismetSystemLibrary::SphereTraceSingle(GetWorld(), Start + NextLoc + FVector(0, 0, 100), Start + NextLoc, 10.f, ETraceTypeQuery::TraceTypeQuery1, false, IgnoreActor, EDrawDebugTrace::ForDuration, SecondHit, true)) {
					if (j == 0) {
						VaultStartPos = SecondHit.Location;
						UKismetSystemLibrary::DrawDebugSphere(GetWorld(), VaultStartPos, 10.f, 12, FColor::Purple, 3);
					}
					else {
						bIsCanWarp = true;
						if (j == 4) {
							VaultLandPos = VaultMiddlePos;
							VaultMotionWarping();
							break;
						}
						//bIsCanWarp = true;
						VaultMiddlePos = SecondHit.Location;
						UKismetSystemLibrary::DrawDebugSphere(GetWorld(), VaultMiddlePos, 10.f, 12, FColor::Orange, 3);
					}
				}
				else {
					FHitResult HitLast;
					if (UKismetSystemLibrary::LineTraceSingle(GetWorld(), GetActorForwardVector() * 80 + SecondHit.TraceStart, GetActorForwardVector() * 80 + SecondHit.TraceStart - FVector(0, 0, 1000), ETraceTypeQuery::TraceTypeQuery1, false, IgnoreActor, EDrawDebugTrace::ForDuration, HitLast, true, FLinearColor::Blue)) {
						VaultLandPos = HitLast.Location;
						UKismetSystemLibrary::DrawDebugSphere(GetWorld(), VaultLandPos, 10.f, 12, FColor::Purple, 3);
						VaultMotionWarping();
						break;
					}

				}
			}break;
		}
	}
}

void ATroyCharacter::VaultMotionWarping()
{
	if (bIsCanWarp/* || Z가 어느정도 범위 안에 있는지.*/) {
		GetCharacterMovement()->SetMovementMode(EMovementMode::MOVE_Flying);
		SetActorEnableCollision(false);

		FMotionWarpingTarget VaultStartMotionWarping;
		VaultStartMotionWarping.Name = FName("VaultStart");
		VaultStartMotionWarping.Location = VaultStartPos;
		VaultStartMotionWarping.Rotation = GetActorRotation();
		MotionWarpComponent->AddOrUpdateWarpTarget(VaultStartMotionWarping);

		FMotionWarpingTarget VaultMiddleMotionWarping;
		VaultMiddleMotionWarping.Name = FName("VaultMiddle");
		VaultMiddleMotionWarping.Location = VaultMiddlePos;
		VaultMiddleMotionWarping.Rotation = GetActorRotation();
		MotionWarpComponent->AddOrUpdateWarpTarget(VaultMiddleMotionWarping);

		FMotionWarpingTarget VaultLandMotionWarping;
		VaultLandMotionWarping.Name = FName("VaultEnd");
		VaultLandMotionWarping.Location = VaultLandPos;
		VaultLandMotionWarping.Rotation = GetActorRotation();
		MotionWarpComponent->AddOrUpdateWarpTarget(VaultLandMotionWarping);

		AnimInstanceRef = GetMesh()->GetAnimInstance();
		if (AnimInstanceRef && VaultMontage) {
			AnimInstanceRef->Montage_Play(VaultMontage);
			/*몽타주 애셋으로부터 인스턴스가 새롭게 생성되서 매번 실행할 때 델리게이트를 설정해주고 있습니다.*/
			FOnMontageEnded OnMontageEnded;
			OnMontageEnded.BindUFunction(this, FName("EndVault"));
			AnimInstanceRef->Montage_SetEndDelegate(OnMontageEnded, VaultMontage);
			//AnimInstance->Montage_JumpToSection(SectionName, Montage);
		}
	}
}

void ATroyCharacter::EndVault()
{
	UE_LOG(LogTemp, Display, TEXT("EndVault"));
	GetCharacterMovement()->SetMovementMode(EMovementMode::MOVE_Walking);
	SetActorEnableCollision(true);
	bIsCanWarp = false;
}
#pragma endregion

대충 아래 사진처럼 SphereTrace를 사용해 앞에 장애물이 있는지 검사하고, 장애물이 있으면 뛰어넘을 수 있는지 검사해서 장애물을 뛰어넘거나 올라가거나 둘중 하나를 실행하는 코드입니다.

물론 간단하게 구현한만큼 버그가 조금 있긴합니다.(벽을 뚫고 간다거나...)

실행영상

Unreal Vaulting

Unreal CameraShake

추향 — Wed, 10 Apr 2024 17:30:32 +0900

Unreal CameraShake

Unreal에서 간단하게 CameraShake를 구현하겠습니다.

"LegacyCameraShake" Class를 생성해줍니다.

(5.1 이전버전에서 "MatineeCameraShake".)

LegacyCameraShake Setting

걷고있을때와 달리고있을때 이렇게 두개를 만드려고합니다.

Walk_LegacyCameraShake 생성자.

bSingleInstance = true;
OscillationDuration = 0.2; //진동지속시간
/*위치 회전*/
RotOscillation.Pitch.Amplitude = 0.3; //회전진동,진폭. 
RotOscillation.Pitch.Frequency = 12;
RotOscillation.Yaw.Amplitude = 0.3;//회전진동,진폭.
RotOscillation.Yaw.Frequency = 6;
RotOscillation.Roll.Amplitude = 0.2;
RotOscillation.Roll.Frequency = 3;
/*loc Oscillation*/
LocOscillation.Z.Amplitude = 0.6;
LocOscillation.Z.Frequency = 12;

Run_LegacyCameraShake 생성자.

bSingleInstance = true;
OscillationDuration = 0.2; //진동지속시간
/*위치 회전*/
RotOscillation.Pitch.Amplitude = 0.5; //회전진동,진폭.
RotOscillation.Pitch.Frequency = 17;
RotOscillation.Yaw.Amplitude = 0.5;//회전진동,진폭.
RotOscillation.Yaw.Frequency = 8;
RotOscillation.Roll.Amplitude = 0.25;
RotOscillation.Roll.Frequency = 5;
/*loc Oscillation*/
LocOscillation.Z.Amplitude = 2;
LocOscillation.Z.Frequency = 17;

적용하기.

이런식으로 적용할 수 있습니다.

void AHorrorPlayerController::PlayerTick(float DeltaTime)
{
	Super::PlayerTick(DeltaTime);
	//#include <GameFramework\CharacterMovementComponent.h>
	UCharacterMovementComponent* CharacterMovementComponent = Cast<UCharacterMovementComponent>(GetPawn()->GetMovementComponent());
	//#include <Kismet\KismetMathLibrary.h>
 	float GroundSpeed = UKismetMathLibrary::VSizeXY(CharacterMovementComponent->Velocity);
	float PlayCameraShakeScale = UKismetMathLibrary::MapRangeClamped(GroundSpeed, 0, 250, 0.f, 1.f);
	ClientStartCameraShake(URunLegacyCameraShake::StaticClass() , PlayCameraShakeScale);
}

https://dev.epicgames.com/documentation/en-us/unreal-engine/API/Plugins/GameplayCameras/ULegacyCameraShake?application_version=5.3

ULegacyCameraShake

Legacy camera shake which can do either oscillation or run camera anims.

dev.epicgames.com

Unreal Decal을 이용해 총알자국 생성하기

추향 — Fri, 5 Apr 2024 00:28:02 +0900

Unreal Decal을 이용해 총알자국 생성하기.

Unreal에서 Decal을 이용해서 총알자국을 생성하는 방법에 대한 글입니다.

간단한 예시지만 응용해서 텍스쳐를 바꾸면 혈흔, 화살표 등의 시각적 효과를 구현하는데 유용하게 사용할 수 있습니다.

현재 글에서 사용한 Bullet Hole Image는 아래 사이트에서 받았습니다.

https://opengameart.org/content/bullet-decal

Bullet Decal

A simple bullet hole decals. I have used it in my first-person shooter.

opengameart.org

Texture 설정.

다운받은 Decal로 사용할 Texture을 설정합니다.

저는 아래의 사진처럼 Sprite Actions->Apply Paper2D Texture Settings를 눌러 설정했습니다.

Material 설정.

메테리얼을 만들어줍니다.

Material Domain을 Deferred Decal로 설정하고 BlendMode 를 Translucent로 설정합니다.

방금 다운받은 Texture Image를 설정합니다.

Alpha를 Opcity에 연결합니다.

SpawnDecal CPP Code.

Texture Image와 Material은 끝났으니 이제 코드부분입니다.

블로그에 옮기면서 필요한 부분만 빼서 수정했습니다.

매개변수로 선언만하고 초기화도 안한 변수가 있긴한데 이거야 뭐..

아무튼 대충 이런식으로 쓰면 됩니다.

FHitResult Hit;
FVector Loc = ViewCamera->GetComponentLocation(); //ViewCamera는 Character에 생성한 UCameraComponent입니다.
FVector Rot = ViewCamera->GetForwardVector();
FCollisionQueryParams CollisionQueryParams(NAME_None, false, this);
TArray<AActor*> Ac;
Ac.Add(this);
if (GetWorld()->LineTraceSingleByChannel(Hit, Loc, Loc + (Rot * 10000), ECollisionChannel::ECC_Visibility, CollisionQueryParams)) { 
//if (UKismetSystemLibrary::LineTraceSingle(GetWorld(), Loc, (Rot * 10000) + Loc, ETraceTypeQuery::TraceTypeQuery1, false, Ac, EDrawDebugTrace::ForDuration, Hit, true)) {
	if (Hit.bBlockingHit) {
		//#include "Components/DecalComponent.h" 필요
		UMaterialInstance* DecalMaterial;
		float DecalLife = 10;
		UGameplayStatics::SpawnDecalAtLocation(GetWorld(), DecalMaterial, FVector(5, 5, 5), Hit.Location, Hit.ImpactNormal.Rotation(), DecalLife)->SetFadeScreenSize(0)
	}
}

실행결과.

실행 결과는 다음과 같습니다.

간단하게 이모티콘 사용하기

추향 — Wed, 3 Apr 2024 07:39:43 +0900

간단하게 이모티콘 사용하기.

윈도우에서 간단하게 이모티콘을 사용하는 방법에 대한 글입니다.

╮（╯＿╰）╭

간단한 설명.

특수 기호를 사용한 이모티콘을 하나하나 작성해서 만드시는 사람도 있으실겁니다.

예를들어 이런 이모티콘이요.(KAomoji)

아니면 이모지라던가...?

이런 이모지를 간편하게 사용할 수 있는 방법에 대한 글입니다.

방법.

설명이 길었는데 방법은 간단합니다.

키보드에서 Window Key+ . 을 누르시면 됩니다.

여러가지가 나오니까 원하는 것을 찾아서 쓰시면 됩니다.

언리얼 스크린 중앙

추향 — Wed, 3 Apr 2024 07:18:17 +0900

언리얼 스크린 중앙.

총을 구현하기 위해 에임을 설정할 때 스크린 중앙을 가져오는 방법은 여러가지가 있습니다.

이 글에서는 간단한 방법 두가지만 작성하였습니다.

APlayerCameraManager를 사용하는 방법과 UCameraComponent를 사용한 방법입니다.

APlayerCameraManager.

//#include "Camera/PlayerCameraManager.h" 필요
APlayerCameraManager* CameraManager = GetWorld()->GetFirstPlayerController()->PlayerCameraManager;
FVector Loc = CameraManager->GetCameraLocation();
FVector Rot = CameraManager->GetActorForwardVector();
//FVector Rot = CameraManager->GetCameraRotation().Vector();

DrawDebugLine(GetWorld(), Loc, (Rot * 1000) + Loc, FColor::Red, false, 10);

UCameraComponent를 사용한 방법.

//Header
UPROPERTY(EditDefaultsOnly, Category = "Camera")
TObjectPtr<USpringArmComponent> SprintArmComponent;
UPROPERTY(EditDefaultsOnly, Category = "Camera")
TObjectPtr<UCameraComponent> ViewCamera;

/*Cpp constructor
*그냥 작성하던 제 코드중 일부 긁어서 복붙해놓았습니다.
*/
SprintArmComponent = CreateDefaultSubobject<USpringArmComponent>(TEXT("SprintArm"));
SprintArmComponent->bUsePawnControlRotation = true;
SprintArmComponent->SetupAttachment(GetMesh(),FName("Head_Camera"));
SprintArmComponent->TargetArmLength = 0.f;
SprintArmComponent->bEnableCameraRotationLag = true;
SprintArmComponent->CameraRotationLagSpeed = 90.f;

ViewCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("ViewCamera"));
ViewCamera->SetupAttachment(SprintArmComponent);

//Other Func
FVector ViewLoc = ViewCamera->GetComponentLocation();
FVector ViewRot = ViewCamera->GetForwardVector();
//FVector ViewRot = ViewCamera->GetComponentRotation().Vector();

DrawDebugLine(GetWorld(), ViewLoc, (ViewRot * 1000) + ViewLoc, FColor::Red, false, 10);

결과.

카메라의 중심에서 앞으로 선을 그리는 예제라서 움직이지 않으면 잘 보이지 않습니다.

그래서 DrawDebugLine의 시간을 길게 설정하였고 아래 사진에서는 위의 코드보다 더 두껍게 설정하였습니다.

처음 서있는 위치.

앞.

발사.

언리얼 한글폰트

추향 — Thu, 28 Mar 2024 06:04:39 +0900

언리얼 한글폰트.

UE5에서 한글 폰트를 적용하는 방법에 대한 글입니다.

해당 글에서 사용한 폰트는 눈누라는 사이트에서 받았습니다.

UMG에 한글폰트 적용하기.

UMG 간단합니다.

다운받은 TTF 파일을 언리얼에 넣어줍니다.

아래 사진처럼 폰트가 생길겁니다.

더 추가하고싶으면 여기에 추가해도 됩니다.

제어판->글꼴에서 원하는 폰트를 넣을수도 있습니다.

아래 사진처럼 들어가면 원하는 폰트를 찾을 수 있습니다.

(저작권 주의.)

이런식으로 그냥 적용해주면 한글폰트가 적용됩니다.

플레이 해보면 잘 적용된 것을 확인할 수 있습니다.

TextRender에 한글폰트 적용하기.

위에서 만들었던 Font파일을 복사했습니다.

Font파일로 들어가서 Font Cach Type을 Runtime에서 Offline으로 바꿔줍니다.

Yes~

원하는 글꼴을 찾고 크기 설정을 해줍니다.

이런식으로 다 깨져서 보일겁니다.

아래 Txt파일을 다운받습니다.

Details에서 Char를 찾아서 붙여넣기를 해줍니다.

KText.txt

0.01MB

Texture PageWidth와 Texture Page Max Height설정을 해줍니다.

이제 저장하고 상단의 Asset의 Reimport 어쩌고저쩌고를 눌러서 Reimport해줍니다.

Reimport 결과입니다.

여기까지 끝났다면 Material을 하나 생성합니다.

Details에서 BlendMode를 Masked로 바꾸고 Two Sided로 설정합니다.

이렇게 만들어줍니다.

Font에는 당연하게도 위에서 만든 폰트를 넣어주시면 됩니다.

TextRender Component를 추가하고 폰트와 Material을 넣어줍니다.

한글이 잘 나오는 것을 확인할 수 있습니다.

Unreal Lightmass executable is Outdated

추향 — Mon, 25 Mar 2024 03:11:33 +0900

Unreal 발생한 오류내용.

"Unreal lightmass executable is outdated. Recompile unrealLightmass project with Development configuration in Visual Studio." 라고 오류가 출력되어 해결해봤습니다.

환경.

GitHub로 받아서 빌드한 Unreal Engine(5.3.2).
Windown 11.

해결한 방법.

저같은 경우에는 엔진을 설치한 경로로 들어가서.

UnrealEngine/Engine/Build/BatchFiles에서 Cmd 실행했습니다.

아래 내용을 입력하고 다시 실행하니 해결되었습니다.

Build.bat UnrealLightmass Win64 Development -verbose

LogHttp: Warning

추향 — Sun, 24 Mar 2024 04:17:26 +0900

LogHttp:Warning

언제부터인지 나오던 LogHttp: Warning 어쩌고저쩌고를 해결하는 방법.

LogHttp: Warning.
해결방법.

LogHttp: Warning

만들던 코드문제는 아닌거같은데 자꾸 거슬리게 나오길래 없애는 방법을 찾아봤습니다.

내용은 아래와 같습니다.(길어서 대충 잘랐습니다.)

LogHttp: Warning: 0000055AEB9EC800: invalid HTTP response code received. 
LogHttp: Warning: 0000055AEB9EC800: request failed, libcurl error: 65 (Send failed since rewinding of the data stream failed)
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 0 (Found bundle for host: 0x55a9d970000 [serially])
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 1 (Re-using existing connection #0 with host datarouter.ol.epicgames.com)
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 2 (Connected to datarouter.ol.epicgames.com (...) port 443 (#0))
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 3 (We are completely uploaded and fine)
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 4 (TLSv1.2 (IN), TLS alert, close notify (256):)
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 5 (Connection died, retrying a fresh connect (retry count: 1))
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 6 (necessary data rewind wasn't possible)
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 7 (Closing connection 0)
LogHttp: Warning: 0000055AEB9EC800: libcurl info message cache 8 (TLSv1.2 (OUT), TLS alert, close notify (256):)
LogHttp: Warning: Retry exhausted on

코드사진

해결방법.

해결방법은 먼저 에디터에 들어갑니다.

Edit->Editor Preferences에서 Usage Data를 검색합니다.

Don't Send를 선택.

Unreal BlueprintNativeEvent

추향 — Thu, 8 Feb 2024 04:16:34 +0900

Unreal BlueprintNativeEvent

이번글은 Unreal UFunction매크로의 BlueprintNativeEvent에 대한 글입니다.

BlueprintNativeEvent를 사용하면 C++에서도 정의 가능하고 블루프린트에서도 재정의가 가능해집니다.

이 내용에 대하여 간단하게 작성하고자 합니다.

BlueprintNativeEvent / cpp
Blueprint

BlueprintNativeEvent / Cpp

이 지정자를 사용하면 C++에서 함수 구현을 하고, 블루프린트로 덮어써서 보조하거나 대체할 수 있게 됩니다.

사용하기 위해서는 _Implementation를 붙인 가상함수를 추가로 선언해야 합니다.

https://docs.unrealengine.com/5.1/ko/ufunctions-in-unreal-engine/

UFunction

게임플레이 클래스용 함수 생성 및 구현 레퍼런스입니다.

docs.unrealengine.com

아래 코드와 같이 사용하면 됩니다.

//ItemBase.h
UFUNCTION(BlueprintNativeEvent)
void Test();//언리얼에서 호출되는 함수.
virtual void Test_Implementation(); //이것만 정의. cpp에서 동작시 호출됨

//ItemBase.cpp
void AItemBase::BeginPlay()
{
	Super::BeginPlay();
	Test();
}
void AItemBase::Test_Implementation()
{
	GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Blue, FString::Printf(TEXT("This is Test_Implementation")));
}

블루프린트(Blueprint)

위 코드를 실행하면 아까 작성한 Text가 나오는 것을 확인할 수 있다.

블루프린트에서 재정의.

cpp에서 작성한 부분은 보이지 않는다.

그럼 이번엔 cpp코드와 블루프린트를 같이 사용해 보겠습니다.

event노드를 우클릭해서 Add Call to Parent Function을 불러옵니다.

이런 식으로 사용하면 됩니다.

끝!

Unreal5 Timeline

추향 — Thu, 21 Dec 2023 06:54:51 +0900

Unreal5 Timeline

Unreal5 Timeline에 대한 글입니다.

타임라인을 사용하여 시간 기반 애니메이션을 만들 수 있습니다.이 글에서는 Timeline을 이용해 카메라 확장과 축소를 구현합니다.

타임라인을 사용하여 구현한 카메라 확장과 축소.
블루프린트로 구현하기.
C++을 이용해 구현하기.

타임라인을 사용하여 구현한 카메라 확장과 축소.

이런 식으로 앉았을 때 카메라가 멀어지고 일어서면 가까워지는 카메라를 Timeline을 사용해 만들었습니다.

파일 크기때문에 프레임 좀 줄였더니 뚝뚝 끊기는군요...

https://docs.unrealengine.com/5.0/ko/timelines-in-unreal-engine/

블루프린트.

블루프린트로는 이렇게 구현했습니다.

특정 키 입력을 받으면 작동합니다.

이후 키를 다시 누르면 원래대로 돌아갑니다.

timeline(CrouchCamDistance)에 들어가는 커브는 간단하게 0.0, 1.0으로 설정했습니다.

요약하면 특정키를 누르면 카메라가 550까지 부드럽게 멀어졌다가 특정키에서 손을 떼면 다시 400으로 돌아오는 간단한 코드입니다.

C++

C++코드도 짧으니까 그냥 긁어서 올리겠습니다.

이름은 BlackCharacter.h인데 ThirdPersonCharacter 예제에 Timeline만 추가한 것으로 생각하시면 됩니다.

기능도 위에 블루프린트로 만든거랑 거의 같고 주석도 있기 때문에 자세한 설명은 하지 않겠습니다.

BlackCharacter.h 코드.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
/*input*/
#include "InputActionValue.h"
/*Timeline*/
#include "Components/TimelineComponent.h"
#include "BlackCharacter.generated.h"


class UInputMappingContext;
class UInputAction;
class USpringArmComponent;
class UCameraComponent;

UCLASS()
class RPG_BLACK_API ABlackCharacter : public ACharacter
{
	GENERATED_BODY()

protected:
	virtual void BeginPlay() override;
	/*CallBack Input*/
	void Move(const FInputActionValue& value);
	void Look(const FInputActionValue& value);
	void Jump()override;
	void StartCrouch();
	void StopCrouch();
	/*Crouch*/
	UPROPERTY(blueprintReadOnly, Category = Movement)
	bool IsCrouching;
	/*Input Action*/
	UPROPERTY(EditAnywhere, Category = Input)
	UInputMappingContext* BlackContext;
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* MovementAction;
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* LookAction;
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* JumpAction;
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* CrouchAction;

	/*Timeline*/
	UPROPERTY(EditAnywhere, Category = TImeline)
	class UCurveFloat* TestCurve;
	FTimeline TestTimeline;
	void BindTestTimeline();
	UFUNCTION()
	void callBackFun(float Value);
	UFUNCTION(Exec)
	void TestPlay();
private:
	/*Character Component*/
	UPROPERTY(VisibleAnywhere)
	USpringArmComponent* CameraBoom;
	UPROPERTY(VisibleAnywhere)
	UCameraComponent* ViewCamera;
public:	
	ABlackCharacter();
	virtual void Tick(float DeltaTime) override;
	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	FORCEINLINE bool GetIsCrouching() const { return IsCrouching; }
};

BlackCharacter.cpp 코드입니다.

#include "Character/BlackCharacter.h"
/*Input*/
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
/*Rotate*/
#include "GameFramework/CharacterMovementComponent.h"
/*SpringArm*/
#include "GameFramework/SpringArmComponent.h"
/*Camera*/
#include "Camera/CameraComponent.h"

// Sets default values
ABlackCharacter::ABlackCharacter()
{
 	// 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;
	//bOrientRotationToMovement 는 현재 캐릭터가 가속값을 가지고 있다면 현재 가속되고있는값 방향으로 캐릭터 메쉬를 회전시켜줍니다.
	GetCharacterMovement()->bOrientRotationToMovement = true;
	/*spring arm*/
	//#include "GameFramework/SpringArmComponent.h"필요
	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
	CameraBoom->SetupAttachment(GetRootComponent());
	CameraBoom->TargetArmLength = 400.f;
	CameraBoom->bUsePawnControlRotation = true;
	/*CharacterRotate*/
	bUseControllerRotationPitch = false;
	bUseControllerRotationRoll = false;
	bUseControllerRotationYaw = false;
	/*Camera*/
	ViewCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("ViewCamera"));
	ViewCamera->SetupAttachment(CameraBoom);
	ViewCamera->SetRelativeLocation(FVector(0, 0, 20));

	IsCrouching = false;
}

// Called when the game starts or when spawned
void ABlackCharacter::BeginPlay()
{
	Super::BeginPlay();
	if (APlayerController* PlayerController = Cast<APlayerController>(GetController())) {
		if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer())) {
			Subsystem->AddMappingContext(BlackContext, 0);
		}
	}
	BindTestTimeline();
}

void ABlackCharacter::Move(const FInputActionValue& value)
{
	const FVector2D MovementVector = value.Get<FVector2D>();
	const FRotator Rotation = Controller->GetControlRotation();
	const FRotator YawRotation(0.f, Rotation.Yaw, 0.f);
	const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
	AddMovementInput(ForwardDirection, MovementVector.Y);
	const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
	AddMovementInput(RightDirection, MovementVector.X);
}

void ABlackCharacter::Look(const FInputActionValue& value)
{
	const FVector2D LookVector = value.Get<FVector2D>();
	AddControllerYawInput(LookVector.X);//도리도리
	AddControllerPitchInput(LookVector.Y);//끄덕끄덕
}

void ABlackCharacter::Jump()
{
	Super::Jump();
}

void ABlackCharacter::StartCrouch()
{
	IsCrouching = true;
	GetCharacterMovement()->MaxWalkSpeed = 350.f;
	//CameraBoom->TargetArmLength = 500.f;
	TestTimeline.PlayFromStart();
}

void ABlackCharacter::StopCrouch()
{
	IsCrouching = false;
	GetCharacterMovement()->MaxWalkSpeed = 500.f;
	//CameraBoom->TargetArmLength = 400.f;
	TestTimeline.ReverseFromEnd();//손을 떼면 반대로.
}

void ABlackCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
	TestTimeline.TickTimeline(DeltaTime);
}

void ABlackCharacter::BindTestTimeline()
{
	if (TestCurve) {
		FOnTimelineFloatStatic TestCallBack;
		FOnTimelineEventStatic TimelineFinishedCallback;
		TestCallBack.BindUFunction(this, "callBackFun");
		TestTimeline.AddInterpFloat(TestCurve, TestCallBack);
		TestTimeline.SetTimelineFinishedFunc(TimelineFinishedCallback);
	}
}
void ABlackCharacter::callBackFun(float Value)
{
	//GEngine->AddOnScreenDebugMessage(-1, 3, FColor::Green, FString::SanitizeFloat(FMath::Lerp(400, 550, Value)));
	CameraBoom->TargetArmLength = FMath::Lerp(400, 550, Value);
}
void ABlackCharacter::TestPlay()
{
	TestTimeline.PlayFromStart();
}

void ABlackCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
	if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent)) {
		EnhancedInputComponent->BindAction(MovementAction, ETriggerEvent::Triggered, this, &ABlackCharacter::Move);
		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &ABlackCharacter::Look);
		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Triggered, this, &ABlackCharacter::Jump);
		EnhancedInputComponent->BindAction(CrouchAction, ETriggerEvent::Started, this, &ABlackCharacter::StartCrouch);
		EnhancedInputComponent->BindAction(CrouchAction, ETriggerEvent::Completed, this, &ABlackCharacter::StopCrouch);
	}
}

Curve파일 및 0.0 , 1.0설정.

생성한 Curve파일을 넣고 사용하니 거의 동일하게 작동했습니다.

The game module "Project Name" Could not be loaded 오류

추향 — Wed, 13 Dec 2023 00:19:31 +0900

The game module "Project Name" Could not be loaded 오류

안녕하세요.

오늘은 유닉스라는 과목을 들으면서 제가 만든 코드를 올려보려고 합니다.

이 글은 언리얼 사용중에 나온 메시지에 대한 내용입니다.

내용설명.
해결방법.

내용 설명.

언리얼 사용중에 오랜만에 프로젝트 빌드를 실행했더니 빌드는 성공했지만 정상적으로 실행되지 않았습니다.

The game module 'project name' could not be loaded. There may be an operating system error, the module may not be properly set up, or a plugin which has been included into the build has not been turned on.

이라는 메시지가 뜨며 정상적으로 실행되지 않는 상태입니다.

해결 방법.

https://www.reddit.com/r/unrealengine/comments/eveyiu/the_game_module_project_name_could_not_be_loaded/

From the unrealengine community on Reddit

Explore this post and more from the unrealengine community

www.reddit.com

이 레딧에서 본것처럼 프로젝트 폴더의 saved\Logs\프로젝트이름.log의 파일을 열어 Missing을 검색해 어떤부분이 문제인지 확인하였습니다.

제 경우에는 HairStrandsCore.dll이 문제인 것 같습니다.

그럼 이제 해당 폴더를 찾아줍니다

E:\Epic Games\UE_5.1\Engine\Plugins\Runtime\HairStrands

이 폴더에서 HairStrands.uplugin을 열어보면 EnableByDefault:false로 되있는데 이걸 true로 바꿔줍니다.

역시 플러그인 문제였는지 바로 실행이 잘 됩니다.

Unity Outline Shader

추향 — Mon, 11 Dec 2023 08:06:42 +0900

Unity Outline Shader

Unity outline에 대한 내용입니다.

윤곽선을 Shader Graph를 이용해 간단하게 만들고 그 결과를 보여줍니다.

*Unity Editer Version 2022.3.0f1

준비
쉐이더 그래프 제작
적용 및 결과

준비

Outline을 적용할 오브젝트를 준비합니다.

3D Cube오브젝트, 3D Chicken, 3D Deer오브젝트를 준비했습니다.

쉐이더 그래프 제작

Shader Graph를 만듭니다.

Create->ShaderGraph->URP->Unlit Shader Graph

Normal Vector는 3D 모델에서 표면의 방향을 나타내는 벡터입니다.

이것을 이용해 Outline 쉐이더 그래프를 간단하게 만들었습니다.

(아래 사진 참고. Shader제작 및 수정 후 save 필수!)

outline.unitypackage

0.00MB

이후 이 쉐이더를 이용해 Material을 생성합니다.

생성한 Material을 눌러 인스펙터창에서 Thick와 Color를 선택합니다.

저는 0.02에 빨간색을 선택했습니다.

적용 및 결과

이제 적용할 오브젝트로 가서 Materials를 하나 더 추가한 후 방금 생성한 메테리얼을 넣어줍니다.

이후 오브젝트를 확인하면 이런식으로 Outline이 생기는 것을 확인할 수 있습니다.

Visual Studio 2022 폰트 변경.

추향 — Fri, 30 Jun 2023 23:59:32 +0900

Visual Studio 폰트 변경.

이 글은 IDE중 하나인 비주얼 스튜디오(Visual Studio)의 폰트변경에 대한 내용을 다루고 있습니다.

Visual Studio 2022를 기반으로 작성되었으며, 이전이나 이후 버전 역시 비슷할 것으로 예상됩니다.

변경하는 방법.
Microsoft 설명.

썸네일

Visual Studio 폰트 변경.

이것이 제 Visual Studio에서 보이는 대문자 i와 l입니다.

알아보기 힘들어서 바꾸는 방법을 찾아봤습니다.

i와 l

Visual Studio를 열어줍니다.

이후 상단에 메뉴에 보이는 도구-> 옵션으로 들어갑니다.

도구-> 옵션

옵션에서 환경(Environment)->글꼴 및 색(Fonts and Colors)로 들어갑니다.

이런식으로 나오는데 원하는 글꼴로 선택하면 됩니다.

아래 사진처럼 샘플로 미리보기도 가능합니다.

Microsoft설명.

이 문서에서 해당 내용을 가져왔습니다.

글꼴에 관한 더 자세한 내용은 여기서 확인할 수 있습니다.

https://learn.microsoft.com/ko-kr/visualstudio/ide/how-to-change-fonts-and-colors-in-visual-studio?view=vs-2022

페이지가 작동하지 않습니다 ERROR 400

추향 — Fri, 9 Jun 2023 04:59:10 +0900

페이지가 작동하지 않습니다 HTTP ERROR 400

페이지가 작동하지 않습니다. 문제가 계속되면 사이트 소유자에게 문의하세요.

HTTP ERROR 400에 대한 간단한 설명과 특정 HTTP ERROR 400오류를 해결하는 방법에 대한 글입니다.

이 글에서는 Tistory에서 발생한 HTTP ERROR 400을 해결합니다.

HTTP ERROR 400.
Tistroy에 발생한 HTTP ERROR 400.
해결방법.

썸네일

HTTP ERROR 400

HTTP ERROR 400은 클라이언트 측에서 잘못된 요청을 서버에 전송했음을 나타내는 상태 코드입니다.

이 오류는 서버가 요청을 이해할 수 없거나 처리할 수 없을 때 발생하며 "Bad Request"라고도 불립니다.

일반적으로 잘못된 구문, 잘못된 요청 매개변수, 보안문제로 인해 발생합니다.

즉, HTTP ERROR 400은 클라이언트 측에서 발생하는 오류이므로, 클라이언트가 요청을 수정하여 해결하는 것이 일반적이며, 서버측에서 발생한 오류는 아닙니다.

Tistory에 발생한 HTTP ERROR 400

티스토리에서 관리 페이지에 들어가려 했는데 페이지가 작동하지 않습니다.

문제가 계속되면 사이트 소유자에게 문의하세요. HTTP ERROR 400이 발생했습니다.

처음에는 티스토리에 문제가 생긴줄 알았는데 좀 지나고 보니까 아닌 것 같더라고요.

위에서 말했다시피 400에러가 나왔기 때문에 제 컴퓨터 문제인것 같았습니다.

해결방법은 간단했습니다.

티스토리 400오류

해결방법.

티스토리에 대한 데이터를 삭제하면서 해결되었습니다.

먼저 크롬의 우측 상단에 보이는 세개의 점("더보기")를 클릭합니다.

이후 "설정"을 눌러 크롬 설정창으로 들어갑니다.

크롬 더보기

크롬 설정 창에 들어가면 여러가지 메뉴가 보이는데 그중에서 "개인 정보 보호 및 보안"으로 들어갑니다.

크롬 설정 탭

개인 정보 보호 및 보안으로 들어가면 "쿠키 및 기타 사이트 데이터"항목이 보일겁니다.

눌러줍니다.

크롬 개인정보 보호 및 보안

"모든 사이트 데이터 및 권한 보기"를 클릭해줍니다.

쿠키 및 기타 사이트 데이터

여기서 티스토리의 데이터만 삭제해주었습니다.

나머지 데이터가 필요한 것이 아니라면 다 지워도 상관없긴합니다.

저는 나머지에 다시 로그인하기 귀찮아서...

모든 사이트 데이터 및 권한 보기

이렇게 삭제할꺼냐고 물어봅니다.

티스토리 데이터 삭제

이렇게 삭제가 완료되었습니다.

데이터 삭제 완료

삭제된 후 티스토리 블로그 관리 페이지에 성공적으로 접속할 수 있게 되었습니다.

티스토리 400 오류 해결

데이터가 꼬이면서 발생한 오류로 추정됩니다.

제 티스토리의 오류는 이렇게 해결이 되었지만, 이 오류의 발생원인에 따라 해결방법이 다를 수 있습니다.

컴퓨터에서 저장 공간이 적게 표시되는 이유

추향 — Tue, 6 Jun 2023 16:30:08 +0900

컴퓨터에서 저장 공간이 적게 표시되는 이유.

1TB라고 표기된 하드디스크/SSD를 구매하여 컴퓨터에 장착한 뒤 윈도우를 통해 보면 931GB로 표시됩니다.

이 글은 하드디스크나 SSD등의 저장장치를 표시한 용량이 실제 컴퓨터에서는 더 적게 표시되는 이유에 대한 내용을 다루는 글입니다.

Data의 단위.
10진 시스템.
2진 시스템.
용량이 더 적게 표시되는 이유.

컴퓨터에서 저장공간이 적게 표시되는 이유

Data의 단위.

컴퓨터에서 용량이 실제로 표시되는 용량보다 적게 나타나는 경우가 있습니다.

이러한 차이를 이해하기 위해서는 데이터의 단위에 대한 이해가 조금 필요합니다.

우선, 컴퓨터의 용량을 측정하는 가장 작은 단위는 Byte입니다.

하지만 이 Byte단위로 용량을 표시하면 너무 큰 숫자가 되어 가독성이 떨어집니다.

그렇기 때문에 일반적으로 더 큰 단위로 표시를 하게 됩니다.

이진법을 사용하는 컴퓨터에서의 데이터 단위.

1 Kbyte(1KB)	1024 Byte
1 Mbye(1MB)	1024 Kbyte
1 Gbyte(1GB)	1024 Mbyte
1 Tbyte(1TB)	1024 Gbyte

10진수로 표기된 용량.

1 Kbyte(1KB)	1000 Byte
1 Mbye(1MB)	1000 Kbyte
1 Gbyte(1GB)	1000 Mbyte
1 Tbyte(1TB)	1000 Gbyte

10진 시스템.

10진수로 1TB를 계산해보겠습니다.

1TB = 1000*1000*1000*1000 = 1,000,000,000,000 Byte가 됩니다.

10진수로 1GB를 계산해 보겠습니다.

1GB = 1000*1000*1000=1,000,000,000 Byte가 됩니다.

10진

2진 시스템.

2진수로 1TB를 계산해 보겠습니다.

1TB = 1024*1024*1024*1024 = 1,099,511,627,776 Byte가 됩니다.

2진수로 1GB를 계산해 보겠습니다.

1GB = 1024*1024*1024 = 1,073,741,824 Byte가 됩니다.

2진

용량이 더 적게 표시되는 이유.

결과적으로 용량이 더 적게 표시되는 이유는, 제조업체가 1TB나 500GB등의 용량을 10진법으로 표기하는 반면, 운영체제와 파일 시스템은 이진법을 사용하여 용량을 계산하기 때문입니다.

제조업체는 주로 10진법을 기준으로 용량을 표시하여 제품을 마케팅합니다. 예를 들어 1TB의 경우, 10진법으로 1000기가바트(1,000,000,000,000바이트)입니다. 그러나 운영체제와 파일 시스템은 이진법을 사용하여 1 테라바이트를 1024기가바이트로 인식합니다.

이러한 2진법과 10진법 간의 차이로 인해 실제로 사용가능한 용량은 표시된 용량보다 조금 작아지게 됩니다.

1 테라를 계산해 보면 1,000,000,000,000 /1024/1024/1024 -> 약 931기가바이트로 표시되게 되는 것입니다.

500GB HDD_Disk

실제로는 완전히 딱 맞아 떨어지는 것은 아니고 여러 가지 이유료 인해 표시되는 용량보다 조금 더 큽니다.

또한 위에서 설명한 이유 외에도 용량이 더 적게 표시되는 경우도 있을 수 있습니다.

하지만 가장 큰 차이가 발생하는 이유는 바로 이러한 이유 때문입니다.

윈도우11 체크박스

추향 — Mon, 5 Jun 2023 17:07:56 +0900

윈도우11 체크박스.

윈도우11에서 어느 날 갑자기 아이콘에 체크박스가 생겼을 경우 또는 체크박스가 필요한 경우 필요한 글입니다.

이 글은 윈도우 11에서 체크박스(항목 확인란)를 추가하거나 제거하는 방법에 대한 글입니다.

항목 확인란 = 체크박스
활성/비활성 방법1.
활성/비활성 방법2.

윈도우11 체크박스 썸네일

항목 확인란 = 체크박스

항목 확인란 -> 즉, 파일에 발생하는 체크표시를 의미합니다.

항목 확인란이 비활성화 되었을 때 평소 사용하던 아이콘으로 보일 것입니다.

(아래 사진 참고.)

항목 확인란 비활성

하지만 활성화 한다면 이런 식으로 아이콘에 체크박스가 생기게 됩니다.

항목 확인란 활성화.

폴더에서는 이런식으로 보입니다.

체크 박스 활성화 폴더예시.

이런 체크박스를 활성화 시키거나 비활성화시키는 방법은 매우 간단합니다.

아래 글을 참고해주세요.

활성/비활성 방법 1.

1. 아무 폴더로 들어갑니다.

폴더

2. 폴더 상단에 보이는 메뉴중에서 "보기"를 선택합니다.

메뉴 "보기"

3. 보기를 눌렀을때 나오는 메뉴 중 "표시"를 클릭하고, "항목 확인란"을 선택합니다.

(아래 사진은 선택하지 않은 사진입니다.)

항목 확인란(체크표시)

활성/비활성 방법 2.

이 방법도 비슷합니다.

1. 아무 폴더나 들어갑니다.

아무 폴더

2. 폴더 상단 메뉴에 보이는 "ººº(자세히 보기)"를 클릭합니다.

메뉴 더보기

3. 자세히 보기를 눌러 나오는 메뉴 중 "옵션"을 선택합니다.

메뉴 더보기 옵션

4. 폴더 옵션 창이 나오면 "보기"탭으로 들어가서 "확인란을 사용하여 항목 선택"을 클릭합니다.

(아래 사진에서는 선택하지 않음.)

확인을 누르면 적용이 완료됩니다.

항목 확인란2

윈도우10 마이크 설정

추향 — Sat, 3 Jun 2023 21:13:04 +0900

윈도우10 마이크 설정.

안녕하세요.

오늘은 윈도우10의 마이크 설정에 대한 글입니다.

마이크 설정 들어가기.
마이크 작동하는지 확인하기.

마이크 설정 들어가기.

마이크 설정 들어가는 방법 두 가지를 알려드리겠습니다.

(둘 다 결과는 같습니다.)

1. 첫번째 방법.-화면 오른쪽에 있는 아이콘으로 들어가기.

윈도우10의 오른쪽 하단을 보면 항상 보이는 스피커 아이콘이 있습니다.

이 아이콘을 우클릭해서 나오는 소리 설정 열기를 눌러줍니다.

소리 설정에 들어갔다면 사운드 제어판으로 들어갑니다.

여기서 마이크 설정을 하면 됩니다.

2. 두 번째 방법.-제어판으로 들어가기.

제어판으로 들어갑니다.

소리로 들어갑니다.

아까와 같은 설정 화면이 나옵니다.

마이크 작동하는지 확인하기.

사용할 마이크를 "사용", "기본 장치"로 설정해놓고 해당 마이크를 두 번 눌러 마이크 속성으로 들어갑니다.

마이크 속성-->수신 대기로 들어가서 이 장치로 듣기(기본 재생 장치)로 해놓으면 마이크 소리가 스피커로 나오게 되어 소리를 확인할 수 있게 됩니다.

추가.

[유용한정보/잡다한것] - 컴퓨터에서 이어폰 마이크 사용하기

[유용한정보/윈도우] - 마이크 인식은 되는데 마이크가 안될 때

[유용한정보/잡다한것] - 피시방처럼 스피커, 헤드셋 전환

윈도우11 요일 표시하기

추향 — Thu, 1 Jun 2023 18:45:16 +0900

윈도우 11 작업표시줄에 요일 표시하기.

안녕하세요.

오늘은 윈도우 11에서 작업 표시줄에 요일을 표시해 보겠습니다.

기본 작업표시줄.
변경하는 방법.
변경 후 작업표시줄.

기본 작업표시줄.

기본적으로 윈도우11을 설치하고 오른쪽 하단의 시간과 날짜가 표시된 부분이 있습니다.

이 부분으로 "시간, 년, 월, 일"을 쉽게 알 수 있습니다.

그런데 이 부분에 기본적으로 요일은 보여주지 않습니다.

마우스를 올리면 요일도 나오지만, 기본적으로 요일도 보여주도록 이 부분을 수정해 보겠습니다.

변경하는 방법.

설정을 눌러줍니다.

설정에 들어가서 "시간 및 언어"를 누르고 "언어 및 지역"을 눌러줍니다.

"언어 및 지역"으로 들어왔다면 "기본 언어 설정"을 눌러줍니다.

"기본 언어 설정"을 누르면 이런 식으로 창이 나오는데 "형식" 탭을 클릭합니다.

"형식" 탭에 들어갔다면 "추가 설정"을 눌러줍니다.

"추가 설정"을 누르면 창이 나오는데 "날짜" 탭을 선택하고 간단한 날짜 부분을 수정하면 됩니다.

이런식으로 수정하면 됩니다.

아래는 다양한 예시입니다. 비슷한 형식으로 변경하면 됩니다.

아마 순서를 바꿔도 될 겁니다.

1. yyyy-MM-dd-ddd

2. yyyy-MM-dd-dddd

3. yyyy-MM-dd-'('ddd')'

4. yyyy-MM-dd-'('dddd')'

5. yyyy-MM-dd-'?'dddd'?'

변경 후 작업표시줄.

저는 위에 예제 5번으로 수정했습니다.

요일이 특이하게 잘 표시되네요.

Unreal5 무기 Collision C++

추향 — Wed, 10 May 2023 15:09:57 +0900

Unreal5 무기 Collision C++

안녕하세요.

이번 글에서는 무기 Collision 설정으로 공격 가능한 상태일 때만 Collision이 활성화되도록 하겠습니다.

[프로그래밍/언리얼] - Unreal5 맞은 방향 알아내기 CrossProduct(외적) c++

Unreal5 맞은 방향 알아내기 CrossProduct(외적) c++

intunknown.tistory.com

Notify추가.
코드수정.
결과.

Notify 추가.

캐릭터 공격 montage에 Notify를 추가해서 무기의 Collision을 공격중일때 활성, 공격중이 아닐 때 비활성으로 만들어주겠습니다.

애니메이션의 공격 모션이 때리는 순간일 때 Collision을 활성화 할 수 있도록 EnableBoxCollision이라는 Notify를 배치하고 때리는 모션이 끝나면 DisableBoxCollision Notify를 배치했습니다.

코드 수정.

Weapon.h 에서 때린 액터를 또 때리지 않도록 IgnoreActors를 추가하고, 외부에서 WeaponBox에 접근할 수 있도록 함수를 추가했습니다.

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

#pragma once

#include "CoreMinimal.h"
#include "Item/Item.h"
#include "Weapon.generated.h"

/**
 * 
 */
class UBoxComponent;
UCLASS()
class SLAYER_API AWeapon : public AItem
{
	GENERATED_BODY()
public:
	AWeapon();//생성자.
	void Equip(USceneComponent* InParent,const FName& InSocketName);
	void AttachMeshToSocket(USceneComponent* InParent, const FName& InSocketName);
	TArray<AActor*> IgnoreActors;
protected:
	virtual void BeginPlay() override;
	UFUNCTION()
	void OnBoxOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
	
private:
	/*Attack*/
	UPROPERTY(VisibleAnywhere, Category = "Weapon Properties")
	UBoxComponent* WeaponBox;
	UPROPERTY(VisibleAnywhere)
	USceneComponent* BoxTraceStart;
	UPROPERTY(VisibleAnywhere)
	USceneComponent* BoxTraceEnd;
public:
	FORCEINLINE UBoxComponent* GetWeaponBox() const { return WeaponBox; }
};

Weapon.cpp에서는 OnBoxOverlap이벤트에 때린것을 또 때리지 않도록 for문을 통해 이전에 Hit가 되었던 것들을 ActorToIgnore에 넣어주었습니다.

void AWeapon::OnBoxOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
	const FVector Start = BoxTraceStart->GetComponentLocation();
	const FVector End = BoxTraceEnd->GetComponentLocation();
	TArray<AActor*> ActorsToIgnore;
	ActorsToIgnore.Add(this);
	//#include "Kismet/KismetSystemLibrary.h"
	FHitResult BoxHit;
	//이전 충돌했던 것 빼기.
	for (AActor* a : IgnoreActors) {
		ActorsToIgnore.AddUnique(a);
	}
	UKismetSystemLibrary::BoxTraceSingle(this,Start,End, FVector(5.f, 5.f, 5.f),BoxTraceStart->GetComponentRotation(), ETraceTypeQuery::TraceTypeQuery1,
		false,ActorsToIgnore,EDrawDebugTrace::None, BoxHit,true);
	IgnoreActors.AddUnique(BoxHit.GetActor());
	
	if (BoxHit.GetActor()) {
		/*Actor를 때렸을 때*/
		IHitInterface* HitInterface = Cast<IHitInterface>(BoxHit.GetActor());
		if (HitInterface) {
			HitInterface->GetHit(BoxHit.ImpactPoint);
		}
	}
}

SlayerCharacter.h 에서는 Enable, Disable어쩌고 Notify가 들어왔을 때 Collision을 설정할 함수를 선언하고, 저번에 실수로 빼먹은 것으로 생각되는 Weapon변수를 선언합니다.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "InputActionValue.h"
#include "CharacterTypes.h"
#include "SlayerCharacter.generated.h"
/*input*/
class UInputMappingContext;
class UInputAction;
/*camera, spring arm*/
class USpringArmComponent;
class UCameraComponent;
/*Equip*/
class AItem;
class AWeapon;
/*Attack*/
class UAnimMontage;
UCLASS()
class SLAYER_API ASlayerCharacter : public ACharacter
{
	GENERATED_BODY()
public:
	ASlayerCharacter();
	virtual void Tick(float DeltaTime) override;
	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	//UFUNCTION(BlueprintCallable)
	void SetWeaponCollision(ECollisionEnabled::Type CollisionEnabled);
protected:
	virtual void BeginPlay() override;
	/*Enhanced input*/ 
	//#include "InputActionValue.h"
	UPROPERTY(EditAnywhere, Category=Input)
	UInputMappingContext* SlayerContext;
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* MovementAction;
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* JumpAction;
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* LookAction;
	void Look(const FInputActionValue& value);
	void Move(const FInputActionValue& value);
	void Jump() override;

	//Equip
	UPROPERTY(VisibleAnywhere, Category = Weapon)
	AWeapon* EquippedWeapon;
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* EkeyAction;
	void EkeyPress();
	//Attack
	UPROPERTY(EditAnywhere, Category = Input)
	UInputAction* AttackAction;
	void Attack();
	void PlayAttackMontage();
private:
	/*camera,spring arm*/
	UPROPERTY(VisibleAnywhere)
	USpringArmComponent* CameraBoom;
	UPROPERTY(VisibleAnywhere)
	UCameraComponent* ViewCamera;
	//Equip
	UPROPERTY(VisibleInstanceOnly)
	AItem* OverlappingItem;
	//Attack
	/*Animation montages*/
	UPROPERTY(EditDefaultsOnly, Category = Montages)
	UAnimMontage* AttackMontage;
	//Attack State
	//#include "CharacterTypes.h"
	ECharacterState CharacterState = ECharacterState::ECS_Unequipped;
	//UPROPERTY(BlueprintReadWrite, meta = (AllowPrivateAccess = "true"))
	EActionState ActionState = EActionState::EAS_Unoccupied;
public:
	FORCEINLINE void SetOverlappingItem(AItem* Item) { OverlappingItem = Item; }
	FORCEINLINE EActionState SetAttackEndState(){ return ActionState = EActionState::EAS_Unoccupied; }
};

SlayerCharacter.cpp 의 EKeyPress에서 오른손에 장착한 Weapon도 EquippedWeapon에 넣어주고, SetWeaponCollision함수도 정의합니다.

// Fill out your copyright notice in the Description page of Project Settings.
#include "Character/SlayerCharacter.h"
/*input*/
#include "EnhancedInputSubsystems.h"
#include "EnhancedInputComponent.h"
/*Rotate*/
#include "GameFramework/CharacterMovementComponent.h"
/*camera, spring arm*/
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
/*Equip*/
#include "Item/Weapons/Weapon.h"
#include "Components/BoxComponent.h"
/*Attack*/
//#include "Animation/AnimMontage.h"
#include "Animation/AnimInstance.h"
// Sets default values
ASlayerCharacter::ASlayerCharacter()
{
 	// 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;
	/*spring arm*/
	//#include "GameFramework/SpringArmComponent.h"필요
	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
	CameraBoom->SetupAttachment(GetRootComponent());
	CameraBoom->TargetArmLength = 300.f;
	CameraBoom->bUsePawnControlRotation = true;
	/*CharacterRotate*/
	bUseControllerRotationPitch = false;
	bUseControllerRotationRoll = false;
	bUseControllerRotationYaw = false;
	//#include "GameFramework/CharacterMovementComponent.h" 추가
	GetCharacterMovement()->bOrientRotationToMovement = true;
	/*Camera*/
	ViewCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("ViewCamera"));
	ViewCamera->SetupAttachment(CameraBoom);
}

// Called when the game starts or when spawned
void ASlayerCharacter::BeginPlay()
{
	Super::BeginPlay();
	//#include "EnhancedInputSubsystems.h" 추가 필요.
	if (APlayerController* PlayerController = Cast<APlayerController>(GetController())) {
		if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer())) {
			Subsystem->AddMappingContext(SlayerContext, 0);
		}
	}
}

void ASlayerCharacter::Look(const FInputActionValue& value)
{
	const FVector2D LookVector = value.Get<FVector2D>();
	AddControllerYawInput(LookVector.X);//도리도리
	AddControllerPitchInput(-LookVector.Y);//끄덕끄덕
}

void ASlayerCharacter::Move(const FInputActionValue& value)
{
	if (ActionState != EActionState::EAS_Unoccupied) return;
	const FVector2D MovementVector = value.Get<FVector2D>();
	const FRotator Rotation = Controller->GetControlRotation();
	const FRotator YawRotation(0.f, Rotation.Yaw, 0.f);
	const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
	AddMovementInput(ForwardDirection, MovementVector.Y);//이동
	const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
	AddMovementInput(RightDirection, MovementVector.X);//이동
}

void ASlayerCharacter::Jump()
{
	Super::Jump(); //Character.h에 있는 Jump사용.
}

void ASlayerCharacter::SetWeaponCollision(ECollisionEnabled::Type CollisionEnabled)
{
	if (EquippedWeapon && EquippedWeapon->GetWeaponBox()) {
		EquippedWeapon->GetWeaponBox()->SetCollisionEnabled(CollisionEnabled);
		UE_LOG(LogTemp, Log, TEXT("SetWeaponCollision"));
		EquippedWeapon->IgnoreActors.Empty();
	}
}

void ASlayerCharacter::EkeyPress()
{
	/*Equip*/
	//#include "Item/Weapons/Weapon.h"
	if (AWeapon* Weapon = Cast<AWeapon>(OverlappingItem)) {
		Weapon->Equip(GetMesh(),FName("RightHandSocket"));
		OverlappingItem = nullptr;
		//무기장착.
		CharacterState = ECharacterState::ECS_EquippedOneHandedWeapon;
		EquippedWeapon = Weapon;
	}
}

/*Attack*/
void ASlayerCharacter::Attack()
{
	//공격중이 아니고, 무기 장착중.
	if (ActionState == EActionState::EAS_Unoccupied && CharacterState != ECharacterState::ECS_Unequipped) {
		PlayAttackMontage();
		ActionState = EActionState::EAS_Attacking;
	}
}

void ASlayerCharacter::PlayAttackMontage()
{
	//#include "Animation/AnimInstance.h"
	UAnimInstance* AnimInstance = GetMesh()->GetAnimInstance();
	if (AnimInstance && AttackMontage) {
		AnimInstance->Montage_Play(AttackMontage);
		const int32 Selection = FMath::RandRange(0,AttackMontage->GetNumSections()-1);
		GEngine->AddOnScreenDebugMessage(1, 2.f, FColor::Cyan, FString::Printf(TEXT("GetSection: %d"), Selection));
		FName SectionName = FName();
		switch (Selection) {
		case 0:
			SectionName = FName("Attack1");
			break;
		case 1:
			SectionName = FName("Attack2");
			break;
		case 2:
			SectionName = FName("Attack3");
			break;
		case 3:
			SectionName = FName("Attack4");
			break;
		case 4:
			SectionName = FName("Attack5");
			break;
		case 5:
			SectionName = FName("Attack6");
			break;
		case 6:
			SectionName = FName("Attack7");
			break;
		case 7:
			SectionName = FName("Attack8");
			break;
		//case 8:
		//	SectionName = FName("Attack9");
		//	break;
		default:
			break;
		}
		//GEngine->AddOnScreenDebugMessage(2, 2.f, FColor::Red, SectionName.ToString());
		AnimInstance->Montage_JumpToSection(SectionName, AttackMontage);
	}
}

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

// Called to bind functionality to input
void ASlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
	//#include "EnhancedInputComponent.h"추가.
	if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent)) {
		EnhancedInputComponent->BindAction(MovementAction, ETriggerEvent::Triggered, this, &ASlayerCharacter::Move);
		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Triggered, this, &ASlayerCharacter::Jump);
		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &ASlayerCharacter::Look);
		EnhancedInputComponent->BindAction(EkeyAction, ETriggerEvent::Triggered, this, &ASlayerCharacter::EkeyPress);
		EnhancedInputComponent->BindAction(AttackAction, ETriggerEvent::Triggered, this, &ASlayerCharacter::Attack);
	}
}

SlayerAnimInstance.h에서 Notify이벤트를 선언합니다.

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

#pragma once

#include "CoreMinimal.h"
#include "Animation/AnimInstance.h"
#include "SlayerAnimInstance.generated.h"

/**
 * 
 */
UCLASS()
class SLAYER_API USlayerAnimInstance : public UAnimInstance
{
	GENERATED_BODY()
public:
	virtual void NativeInitializeAnimation() override;
	virtual void NativeUpdateAnimation(float DeltaTime) override;
	UPROPERTY(BlueprintReadOnly)
	class ASlayerCharacter* SlayerCharacter;
	UPROPERTY(BlueprintReadOnly, Category = Movement)
	class UCharacterMovementComponent* SlayerCharacterMovement;
	UPROPERTY(BlueprintReadOnly, Category = Movement)
	float GroundSpeed;
	UPROPERTY(BlueprintReadOnly, Category = Movement)
	bool isFalling;
	UFUNCTION()
	void AnimNotify_AttackEnd();
	UFUNCTION()
	void AnimNotify_EnableBoxCollision();
	UFUNCTION()
	void AnimNotify_DisableBoxCollision();
	
};

SlayerAnimInstace.cpp에서 EnableBoxCollision Notify가 발생하면 Collision이 QueryOnly가 되도록 하고, 공격이 끝나면(DisalbeBoxCollision) Collision을 NoCollision이 되도록 정의하였습니다.

// Fill out your copyright notice in the Description page of Project Settings.
#include "Character/SlayerAnimInstance.h"
#include "Character/SlayerCharacter.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Kismet/KismetMathLibrary.h"
void USlayerAnimInstance::NativeInitializeAnimation()
{
	Super::NativeInitializeAnimation();
	SlayerCharacter = Cast<ASlayerCharacter>(TryGetPawnOwner());
	if(SlayerCharacter){
		//#include "GameFramework/CharacterMovementComponent.h" 필요.
		SlayerCharacterMovement = SlayerCharacter->GetCharacterMovement();
	}
}
void USlayerAnimInstance::NativeUpdateAnimation(float DeltaTime)
{
	Super::NativeUpdateAnimation(DeltaTime);
	if (SlayerCharacterMovement) {
		//#include "Kismet/KismetMathLibrary.h"
		GroundSpeed = UKismetMathLibrary::VSizeXY(SlayerCharacterMovement->Velocity);
		isFalling = SlayerCharacterMovement->IsFalling();
	}
}
void USlayerAnimInstance::AnimNotify_AttackEnd()
{
	SlayerCharacter->SetAttackEndState();
}
void USlayerAnimInstance::AnimNotify_EnableBoxCollision()
{
	SlayerCharacter->SetWeaponCollision(ECollisionEnabled::QueryOnly);
}
void USlayerAnimInstance::AnimNotify_DisableBoxCollision()
{
	SlayerCharacter->SetWeaponCollision(ECollisionEnabled::NoCollision);
}

결과.

이렇게 수정하니 한번 공격에 여러 번 맞는 문제나 공격도 안 했는데 Hit Reaction애니메이션이 나가는 문제는 사라졌습니다.

근데 이거 계속 작성하면 코드 수정이랑 가독성이 좀 아쉽기도 하고, 어느 정도 힌트는 될 수 있다고 생각하지만 코드 자체는 저만 알아볼 수 있는 코드가 되어버려서...

블로그에 계속 이런 식으로 쓰는 것은 생각 좀 다시 해봐야 될 것 같아요.