코딩생존기

n 길이의 배열을 각 인덱스로 초기화한 다음 m번동안 i번째부터~j번째까지를 뒤집어주면 된다.

이때 reverse 함수를 활용하여 풀 수 있다.

reverse함수는 시작과 끝을 정해주면 그 구간을 뒤집어 준다.

정답코드

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


int main()
{
    int n, m;
    cin >> n >> m;
    
    vector<int> v(n);

    for (int i = 0;i < n;i++)
    {
        v[i] = i + 1;
    }

    for (int x = 0;x < m;x++)
    {
        int i, j;
        cin >> i >> j;
        reverse(v.begin() + i - 1, v.begin() + j);
    }
    
    for (int it : v)
    {
        cout << it << " ";
    }

    return 0;
}

배열을 입력받고 최댓값과 그 값이 몇 번째 수인지 출력하면 된다.

max_element함수를 통해 최댓값을 출력해주고

이 함수에서 v.begin()을 빼주는 것으로 index도 알아내자. 이때 index로 나오기 때문에 +1을 해주어야한다.

이렇게 되는 이유는

vector는 일련의 반복자로 구성되어 있으므로 최대값을 가리키는 반복자를 맨 처음을 가리키는 v.begin()만큼 빼준다면 인덱스 값을 구할 수 있다.

정답코드

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    vector<int> v(9);
    for (int i = 0;i < 9;i++)
    {
        cin >> v[i];
    }

    cout << *max_element(v.begin(), v.end()) <<"\n" << max_element(v.begin(), v.end()) - v.begin() + 1;

    return 0;
}

https://www.acmicpc.net/problem/10818

수의 배열을 입력받고 최솟값과 최댓값을 출력해주면 되는 문제이다. 처음에 정렬한 다음 처음과 끝 값을 출력하려고 했는데 정렬이 nlogn의 시간이 걸리고 min max element를 출력해주는 함수는 n의 시간이 걸리기 때문에 더 효율적이라고 한다.

하지만 limits 라이브러리를 활용하여 배열을 사용하지 않고도 이 문제를 해결할 수도 있다. 이때 limits함수의 max min을 저장해두고 만약 더 큰값이나 더 작은 값이 있다면 이 값으로 변경해주면 된다.

정답코드(배열 사용)

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    int n;
    cin >> n;
    vector<int> v(n);
    for (int i = 0;i < n;i++)
    {
        cin >> v[i];
    }

    cout << *min_element(v.begin(),v.end()) << " " << *max_element(v.begin(),v.end());

    return 0;
}

정답코드(limits 라이브러리 사용)

#include <iostream>
#include <limits>

using namespace std;

int main() {
    int n, num;
    cin >> n;

    int minVal = numeric_limits<int>::max();
    int maxVal = numeric_limits<int>::min();

    for (int i = 0; i < n; i++) {
        cin >> num;
        if (num < minVal) minVal = num;
        if (num > maxVal) maxVal = num;
    }

    cout << minVal << " " << maxVal << "\n";
    return 0;
}

https://www.acmicpc.net/problem/11054

바이토닉 수열 중에 가장 긴 길이를 찾으려면 LIS 알고리즘을 사용하면된다.

이 LIS를 왼쪽에서 오른쪽으로 가면서 i번째를 기준으로 하는 가장 긴 증가하는 부분 수열 길이를 구하고 

오른쪽에서 왼쪽으로 가면서  i번째를 기준으로 하는 가장 긴 감소하는 부분 수열 길이를 더하고 중복되는 i번째를 빼주면 된다.

정답코드

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int dp_lis(vector<int>& v)
{
	int size = v.size();
	vector<int> dp1(size, 1), dp2(size, 1);

	//왼쪽->오른쪽
	for (int i = 0; i < size; i++)
	{
		for (int j = 0; j < i; j++)
		{
			if (v[j] < v[i])
			{
				dp1[i] = max(dp1[i], dp1[j] + 1);
			}
		}
	}

	//오른쪽->왼쪽
	for (int i = size - 1; i >= 0; i--)
	{
		for (int j = size - 1; j > i; j--)
		{
			if (v[j] < v[i])
			{
				dp2[i] = max(dp2[i], dp2[j] + 1);
			}
		}
	}

	// 각 `i`에서 `dp1[i] + dp2[i] - 1`의 최댓값 찾기
	int maxLength = 0;
	for (int i = 0; i < size; i++) {
		maxLength = max(maxLength, dp1[i] + dp2[i] - 1);
	}

	return maxLength;
}


int main()
{
	int n;
	cin >> n;
	vector<int>v(n);
	for (int i = 0; i < n; i++)
	{
		cin >> v[i];
	}

	cout << dp_lis(v) << "\n";
}

https://www.acmicpc.net/problem/2156

n개의 포도주 잔이 있을 때 최대로 마실 수 있는 포도주의 양을 계산해야한다. 

n번째 잔까지의 최적의 값을 누적해나가면서 풀면 된다. 

DP로 풀 경우 초기값을  설정하고 점화식을 도출하자.

3잔 연속해서 마실 수 없기 때문에 

경우의 수를 생각해보면 

우선 i번재 잔을 마신다고 가정했을 때 

i-1번째 잔을 마시면 i-2번째 잔은 마실 수 없기 때문에 i-3번째까지의 최대 값과 더해주면 된다.

i-1번째 잔을 마시지 않으면 i-2번째잔까지의 최대 값과 더해주면 된다.

i번째 잔을 마시지 않으면

i-1번째의 최대 값과 더해주면 된다.

이 3가지 경우의 수 중에 제일 큰 값을 저장해 가면서 n까지 값을 갱신하면 된다.

최종코드

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
	int n;
	cin >> n;
	vector<int> wine(n + 1, 0);
	vector<int> dp(n + 1, 0);

	for (int i = 1; i <= n; i++) {
		cin >> wine[i];
	}
	//초기값 설정
	dp[1] = wine[1];
	if (n > 1) dp[2] = wine[1] + wine[2];
	if (n > 2) dp[3] = max({ wine[1] + wine[2], wine[1] + wine[3], wine[2] + wine[3] });
	//점화식 3가지 중에 제일 큰걸로
	for (int i = 4; i <= n; i++) {
		dp[i] = max({ dp[i - 1], dp[i - 2] + wine[i], dp[i - 3] + wine[i - 1] + wine[i] });
	}

	cout << dp[n] << "\n";
	return 0;
}

https://www.acmicpc.net/problem/10844

길이가 N인 계단수를 구해야하는 문제이다. 시간 제한이 1초이기 때문에 당연하게도 브루트 포스하게 풀면 시간초과가 난다. 이러한 문제는 DP를 통해 풀어야한다.

이때 중요한 점은 점화식을 도출해내야하는 것이다. 

쉽게 생각해보면 각 자릿수에서 0일때는 1이 계단수이고 9일때는 8이 계단수이고 나머지 수는 +1 -1이 계단수이기 때문에 초기값을 할당해준 다음 이를 미리 계산해두면 될 것이다.

점화식과 초기값은 다음과 같다

이때 1~8까지의 수를 더 해줄때 값이 초과될 수 있기 때문에 문제에서 정의해준 나누는 수로 나눠주자.

또한 N길이의 모든 계단 수를 더 해줄때도 더해주면서 값이 초과할 수 있기 때문에 더해줄때 나눠주는 것을 추가하자.

최종코드

#include <iostream>

#define MOD 1000000000

using namespace std;

int dp[101][10] = { 0 };  //길이 / 자릿수
int main()
{
	int n;
	cin >> n;
	long answer = 0;

	for (int j = 1; j < 10; j++)
	{
		dp[1][j] = 1;		//초기값 설정
	}

	for (int i = 2; i <=n; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (j == 0) dp[i][j] = dp[i - 1][j + 1];
			else if (j == 9) dp[i][j] = dp[i - 1][j - 1];
			else dp[i][j] = (dp[i - 1][j + 1]+dp[i - 1][j - 1])%MOD;
		}
	}

	for (int j = 0; j < 10; j++)
	{
		answer = (answer + dp[n][j]) % MOD;;
	}

	cout << answer << endl;

	return 0;
}

이제 순찰 중에 플레이어를 만나면 쫓아가도록 구현해보자

이때 Pawn Sensing Component를 통해 플레이어를 감지할 수 있다.

 블루프린트 상에서 추가해보면 다양한 속성을 볼 수 있는데 이때 듣는것과 보는것 모두 감지거리를 조정해줄 수 있다.

LOS는 최대로 들을 수 있는 거리이다.

이를 코드로 구현해보자. 우선 UPawnSensingComponent 를 전방선언해주고 이를 DefaultSubObject로 생성해주고 시야각과 시야범위를 설정해주자. 그리고 플레이어를 감지했을 때의 콜백 함수를 지정해주자.

Enemy.h

private:
	UPROPERTY(VisibleAnywhere)
	class UPawnSensingComponent* PawnSensing;
    
protected:
    UFUNCTION()
	void PawnSeen(APawn* SeenPawn);

Enemy.cpp

AEnemy::AEnemy()
{
    PawnSensing = CreateDefaultSubobject<UPawnSensingComponent>(TEXT("PawnSensing"));
	PawnSensing->SightRadius = 4000.f;
	PawnSensing->SetPeripheralVisionAngle(45.f);
}

void AEnemy::BeginPlay()
{
	Super::BeginPlay();
	if (HealthBarWidget)
	{
		HealthBarWidget->SetVisibility(false);
	}

	EnemyController = Cast<AAIController>(GetController());
	
	MoveToTarget(PatrolTarget);

	if (PawnSensing)
	{
		PawnSensing->OnSeePawn.AddDynamic(this, &AEnemy::PawnSeen);
	}
}

void AEnemy::PawnSeen(APawn* SeenPawn)
{

}

이렇게 해준 다음 이제 적의 Patrol Chase Attack 상태를 나누면서  쫓아가는 로직 구현해보자

우선 enum class를 통해 각 state를 나눠주자.

UENUM(BlueprintType)
enum class EEnemyState : uint8
{
	EES_Patrolling UMETA(DisplayName = "Patrolling"),
	EES_Chasing UMETA(DisplayName = "Chasing"),
	EES_Attacking UMETA(DisplayName = "Attacking"),
};

이렇게 해준 다음 Enemy클래스에서 이 enum class 변수를 가지고 있게 하자.

Enemy.h

private:
	EEnemyState EnemyState = EEnemyState::EES_Patrolling;

그리고 Pawn을 발견했을 때 쫓아가도록 해야한다. 이때 Cast로 검사를 해주게 되면 이 함수의 연산 간격이 짧기 때문에  연산부하가 많이 지게 된다. 이때 특정 태그값을 가지고 있는지 검사해주면 된다. 

SlashCharacter.cpp

void ASlashCharacter::BeginPlay()
{
	Tags.Add(FName("SlashCharacter"));
}

Enemy.cpp

void AEnemy::PawnSeen(APawn* SeenPawn)
{
	if (EnemyState == EEnemyState::EES_Chasing) return;

	//Chase
	if (SeenPawn->ActorHasTag(FName("SlashCharacter")))
	{
		EnemyState = EEnemyState::EES_Chasing;
		GetWorldTimerManager().ClearTimer(PatrolTimer);
		GetCharacterMovement()->MaxWalkSpeed=300.f;
		CombatTarget=SeenPawn;
		MoveToTarget(CombatTarget);
	}
}

이렇게 해주면 잘 쫓아오는 것을 알 수 있다.

이렇게 해주고 반경 안에서 사리지면 다시 Patrol하도록 해주자.

void AEnemy::CheckCombatTarget()
{
	if (!InTargetRange(CombatTarget, CombatRadius))
	{
		//바깥이면 Patrol로
		CombatTarget = nullptr;
		if (HealthBarWidget)
		{
			HealthBarWidget->SetVisibility(false);
			Attributes->SetHealth(100.f);
		}
		EnemyState = EEnemyState::EES_Patrolling;
		GetCharacterMovement()->MaxWalkSpeed = 125.f;
		MoveToTarget(PatrolTarget);
	}
}

이제 여기서 Attack State로 바꾸고 Attack을 할 수 있게 Attack Radius를 지정해주어야 한다. 그리고 이제 CheckCombatTarget함수에서 플레이어와의 거리를 측정해서 Patrol Chase Attack상태가 나눠지도록 조건문을 구성해주자. 이때 PawnSeen함수에서 공격상태가 아닐때만 Chase하도록 해주자. 

Enemy.h

private:
	UPROPERTY(EditAnywhere)
	double AttackRadius = 150.f;

Enemy.cpp

void AEnemy::PawnSeen(APawn* SeenPawn)
{
	if (EnemyState == EEnemyState::EES_Chasing) return;

	//Chase
	if (SeenPawn->ActorHasTag(FName("SlashCharacter")))
	{
		GetWorldTimerManager().ClearTimer(PatrolTimer);
		GetCharacterMovement()->MaxWalkSpeed=300.f;
		CombatTarget=SeenPawn;

		if (EnemyState != EEnemyState::EES_Attacking)
		{
			EnemyState = EEnemyState::EES_Chasing;
			MoveToTarget(CombatTarget);
		}
	}
}

void AEnemy::CheckCombatTarget()
{
	if (!InTargetRange(CombatTarget, CombatRadius))
	{
		//바깥이면 Patrol로
		CombatTarget = nullptr;
		if (HealthBarWidget)
		{
			HealthBarWidget->SetVisibility(false);
			Attributes->SetHealth(100.f);
		}
		EnemyState = EEnemyState::EES_Patrolling;
		GetCharacterMovement()->MaxWalkSpeed = 125.f;
		MoveToTarget(PatrolTarget);
	}
	else if (!InTargetRange(CombatTarget, AttackRadius) && EnemyState != EEnemyState::EES_Chasing)
	{
		//공격반경 바깥
		EnemyState = EEnemyState::EES_Chasing;
		GetCharacterMovement()->MaxWalkSpeed = 300.f;
		MoveToTarget(CombatTarget);
	}
	else if (InTargetRange(CombatTarget, AttackRadius) && EnemyState != EEnemyState::EES_Attacking)
	{
		//공격 반경 내부
		EnemyState = EEnemyState::EES_Attacking;
		//공격
	}
}

하지만 지금만약 적의 뒤에서 공격을 하면 아무 반응이 없다. 이러한 점을 고쳐보도록 하자. 이는 TakeDamage함수에서 지정해줄 수 있다.

float AEnemy::TakeDamage(float DamageAmount, FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser)
{
	if (Attributes)
	{
		Attributes->ReceiveDamage(DamageAmount);
		HealthBarWidget->SetHealthPercent(Attributes->GetHealthPercent());
	}

	CombatTarget = EventInstigator->GetPawn();
	EnemyState = EEnemyState::EES_Chasing;
	GetCharacterMovement()->MaxWalkSpeed = 300.f;
	MoveToTarget(CombatTarget);

	return DamageAmount;
}

마지막으로 적에게 무기를 장착하기 위해 다양한 무기들을 추가해보자. 이때 무기 에셋마다 각 Origin(Pivot)이 다르기 때문에 조심해야한다.

우선 무료 무기 에셋 중에 Free Fantasy Weapon Sample Pack이라는 에셋을 추가하여 사용해보자. 무기 중에 Axe를 보면 원점이 손잡이에 있는 것을 볼 수 있다.

https://www.fab.com/ko/listings/d5be0dc9-1a41-4be2-a63a-5ed436f3445d

이 Axe로 매쉬를 변경하고 실행해서 잡아보면 문제가 생기는 것을 알 수 있다. 손에서 떨어져 있으며 도끼의 방향도 잘 못된것을 알 수 있다.

이렇게 된 무기들의 원점을 동일하게 바꿔주어야하는데 이를 위해 Blender를 사용하자. Blendor에서 사용하려면 해당 에셋을 Export해주어야한다.

Blender에서는 fbx 파일을 가져와서 에디트 모드로 a키를 눌러 모두 선택한 다음들어간다음 R키를 누르고 Y키를 눌러 y축이 고정된 상태로 180도 회전시켜주면된다. 그리고 G키와 Z키를 통해 원점을 Z축이 고정된 상태로 손잡이로 바꾸주자.

마지막으로 크기는 S키를 누르면 변경할 수있다. 완성된 fbx파일은 이름을 기존 것과 다르게 해준 다음 다시 언리얼에서 임폴트 해주자.

임폴트한 에셋에 머티리얼은 이전것과 동일한 것으로 지정해주자. 이렇게 해주면 이전과 다르게 잘 잡고 있는 것을 볼 수 있다.

https://www.acmicpc.net/problem/11066

DP를 활용해서 풀 수 있는 문제이다.

우선 어떤 값을 동적 계획을 통해 미리 계산해둘지 생각해보면 지금 필요한 것이 i번째부터 j번째까지 파일을 합칠 때의 최소비용을 구해야하기 때문에 결과적으로 dp배열에는 최소비용이 들어가야한다.

• dp[i][j] = i번째부터 j번째 파일까지 합치는 최소 비용
• sum[i][j] = i~j까지의 파일 크기의 합 (누적합 사용)

DP 점화식은 다음과 같다.

dp[i][j] = min(dp[i][k] + dp[k+1][j] + sum[i][j]) (i ≤ k < j)

• dp[i][k] : 왼쪽 부분을 먼저 합친 최소 비용
• dp[k+1][j] : 오른쪽 부분을 먼저 합친 최소 비용
• sum[i][j] : 두 개를 합치는 비용

최종 DP 알고리즘 진행 순서

1. sum[i][j]을 미리 계산해서 누적합을 저장 (sum[i][j] = sum[i][j-1] + size[j]).
2. 파일 길이(구간 크기) 2부터 K까지 증가시키면서 DP를 계산.
3. 최소 비용을 구하기 위해 구간을 나누는 모든 경우를 탐색 (dp[i][k] + dp[k+1][j] + sum[i][j]). -> 순환 탐색 i~j까지
4. 최종적으로 dp[1][K] 가 정답.

최종코드

#include <iostream>
#include <vector>
#include <climits>

using namespace std;

int main() {
    int t;
    cin >> t;

    while (t--) {
        int k;
        cin >> k;

        vector<int> files(k + 1);
        vector<vector<int>> dp(k + 1, vector<int>(k + 1, 0));
        vector<int> prefixSum(k + 1, 0);

        // 파일 크기 입력 & 누적합(prefix sum) 계산
        for (int i = 1; i <= k; i++) {
            cin >> files[i];
            prefixSum[i] = prefixSum[i - 1] + files[i]; // 누적합 저장
        }

        // DP 테이블 채우기 (구간 길이 2부터 K까지)
        for (int len = 2; len <= k; len++) { // 파일을 합치는 구간 길이
            for (int i = 1; i + len - 1 <= k; i++) { // 시작점
                int j = i + len - 1; // 끝점
                dp[i][j] = INT_MAX; // 최소값을 찾기 위해 큰 값으로 초기화

                // 최적의 분할점을 찾기
                for (int mid = i; mid < j; mid++) {
                    dp[i][j] = min(dp[i][j], dp[i][mid] + dp[mid + 1][j] + (prefixSum[j] - prefixSum[i - 1]));
                }
            }
        }

        // 정답 출력 (전체 파일을 합치는 최소 비용)
        cout << dp[1][k] << '\n';
    }

    return 0;
}

이제 단일 지점으로의 Patrol은 가능한 것을 볼 수 있다. 이제 한 Patrol Point에서 다른 Patrol Point로 이동할 수 있도록 구현해보자.

이를 위해 타켓포인트를 여러개 만들어주고 배열에 할당해주자

그리고 Tick함수에서 Target과의 거리를 측정해주는 함수가 작동할 수 있도록 Actor와의 지정해준 거리에 따라 bool값을 반환해주는 새로운 함수를 만들어주자.

Enemy.cpp

bool AEnemy::InTargetRange(AActor* Target, double Radius)
{
	const double DistanceToTarget = (Target->GetActorLocation() - GetActorLocation()).Size();
	return DistanceToTarget <= Radius;
}

이를 바탕으로  Tick함수에서 HealthBar 조건문도 변경해주고 PatrolTarget조건문도 만들어주자.

이때 PatrolRadius(멈출 거리)를 지정해주어야하는데 이 값이 double인데 moveTo에서는 이 반경보다 조금 더 이동하기 때문에 조금 더 거리를 지정해주어야한다.

Enemy.h

	UPROPERTY(EditAnywhere)
	double PatrolRadius = 200.f;

Enemy.cpp

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

	if (CombatTarget)
	{
		if (!InTargetRange(CombatTarget,CombatRadius))
		{
			CombatTarget = nullptr;
			if (HealthBarWidget)
			{
				HealthBarWidget->SetVisibility(false);
				Attributes->SetHealth(100.f);
			}
		}
	}

	if (PatrolTarget && EnemyController)
	{
		TArray<AActor*> ValidTargets;
		for (AActor* Target : PatrolTargets)
		{
			if (Target != PatrolTarget)
			{
				ValidTargets.AddUnique(Target);
			}
		}


		if (InTargetRange(PatrolTarget, PatrolRadius))
		{
			const int32 TargetSelection = FMath::RandRange(0, ValidTargets.Num() - 1);
			PatrolTarget = ValidTargets[TargetSelection];
			
			FAIMoveRequest MoveRequest;
			MoveRequest.SetGoalActor(PatrolTarget);
			//도착이라고 생각할 거리
			MoveRequest.SetAcceptanceRadius(15.f);
			EnemyController->MoveTo(MoveRequest);
		}
	}
}

이렇게 해주고 실행해주면 랜덤한 순찰포인트로 순찰하는 것을 볼 수 있다.

하지만 지금은 순찰 포인트로 이동하고 바로 다른 포인트로 이동하는데 이것을 조금 기다렸다가 다른 순찰포인트로 이동하도록 구현해보자. 

이를 위해 FTimerHandle 구조체 변수를 선언해주자. 이 구조체 변수는 일정 시간이 지난후  호출될 콜백함수가 필요하기 때문에 함수도 같이 선언해주자.

Enemy.h

private:
	FTimerHandle PatrolTimer;
	void PatrolTimerFinished();

Enemy.cpp

void AEnemy::PatrolTimerFinished()
{
	MoveToTarget(PatrolTarget);
}

이렇게 콜백함수를 만들어준 다음 기능별로 나눌 수 있는것은 나눠주자.

Enemy.cpp

bool AEnemy::InTargetRange(AActor* Target, double Radius)
{
	if (Target == nullptr) return false;
	const double DistanceToTarget = (Target->GetActorLocation() - GetActorLocation()).Size();
	DRAW_SPHERE_SingleFrame(GetActorLocation());
	DRAW_SPHERE_SingleFrame(Target->GetActorLocation());
	return DistanceToTarget <= Radius;
}

void AEnemy::MoveToTarget(AActor* Target)
{
	if (EnemyController == nullptr || Target == nullptr) return;

	FAIMoveRequest MoveRequest;
	MoveRequest.SetGoalActor(Target);
	//도착이라고 생각할 거리
	MoveRequest.SetAcceptanceRadius(15.f);
	EnemyController->MoveTo(MoveRequest);
}

AActor* AEnemy::ChoosePatrolTarget()
{
	TArray<AActor*> ValidTargets;
	for (AActor* Target : PatrolTargets)
	{
		if (Target != PatrolTarget)
		{
			ValidTargets.AddUnique(Target);
		}
	}

	if (ValidTargets.Num() > 0)
	{
		const int32 TargetSelection = FMath::RandRange(0, ValidTargets.Num() - 1);
		return ValidTargets[TargetSelection];
	}
	return nullptr;
}

만약 타켓이 거리안에 있다면 5초를 대기한 다음 이동하게 해주자 이때 GetWorldTimerManager의 SetTimer 기능을 활용하면 된다.

Enemy.cpp

void AEnemy::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
	
	if (InTargetRange(PatrolTarget, PatrolRadius))
	{
		PatrolTarget = ChoosePatrolTarget();
		GetWorldTimerManager().SetTimer(PatrolTimer, this, &AEnemy::PatrolTimerFinished, 5.f);
	}
	
}

이렇게 해주면 5초를 대기한 다음 다음 순찰포인트로 이동한다.

이전 시간에 애니메이션을 임포트해주었으니 이제 올바른 상황에 맞게 출력되도록 설정해주자 

애니메이션 블루프린트의 Main State에 Blend Space를  사용하는 것으로 걷고 뛰는 애니메이션이 재생되도록 해주자.

이때 Blend Space는 속도와 같은 변수 값의 상태에 따라 다른 애니메이션이 재생되도록 해준다.

이를 위해 애니메이션/블랜드스페이스1D를 생성해주자.

가로축의 이름을 GroundSpeed로 바꿔주고 최소를0 최대를 300으로 해준다음 Idle Walk Run을 배치해주자

이렇게 배치해준다음 Idle State에서 애니메이션 포즈가 이 Blend Space를 통해 출력되도록 수정해주자

이렇게 해주고 이제 적의 속도를 가져와야하기 때문에 이벤트그래프에서 적캐릭터 BP를 가져오고 BP에 있는 Character Movement도 가져오도록 수정해주자.

그리고 Float로 GroundSpeed라는 변수를 선언해주고 Thread Safe Update Animation에서 이 GroundSpeed를 설정해줄 수 있도록 해주자.

그 다음, 이 변수 값을 가져와서 Blend Space 입력에 넣어주자

이렇게 해주면 움직임이 한쪽으로 치우쳐보이는데 이는 Character에서 Orient 값을 체크해주고 BP_Enemy의 컨트롤러 요 사용을 꺼주면 된다.

이를 코드로 구현해보자

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

	GetMesh()->SetCollisionObjectType(ECollisionChannel::ECC_WorldDynamic);
	GetMesh()->SetCollisionResponseToChannel(ECollisionChannel::ECC_Visibility, ECollisionResponse::ECR_Block);
	GetMesh()->SetCollisionResponseToChannel(ECollisionChannel::ECC_Camera, ECollisionResponse::ECR_Ignore);
	GetMesh()->SetGenerateOverlapEvents(true);
	GetCapsuleComponent()->SetCollisionResponseToChannel(ECollisionChannel::ECC_Camera, ECollisionResponse::ECR_Ignore);

	Attributes = CreateDefaultSubobject<UAttributeComponent>(TEXT("Attributes"));
	HealthBarWidget = CreateDefaultSubobject<UHealthBarComponent>(TEXT("HealthBar"));
	HealthBarWidget->SetupAttachment(GetRootComponent());

	GetCharacterMovement()->bOrientRotationToMovement = true;
	bUseControllerRotationPitch = false;
	bUseControllerRotationRoll = false;
	bUseControllerRotationYaw = false;
}

걷는 모션이 생겼으니 이제 특정 포인트를 순찰하도록 만들어보자. 여러 포인트를 가진 다음 상황에 따라 특정 포인트를 선택하여 순찰하도록 구현해보자. 이를 위해 AActor값의 TArray를 만들어주자.

Enemy.h

private:
	UPROPERTY(EditInstanceOnly,Category="AI Navigation")
	AActor* PatrolTarget;

	UPROPERTY(EditInstanceOnly, Category = "AI Navigation")
	TArray<AActor*> PatrolTargets;

이를 활용하기 위해 AAIController의 MoveTo함수를 사용하자.

이를 사용하려면 모듈에 AIModule을 추가해줘야한다. 이렇게 해준 다음 순찰타켓을 지정해주고 옵션값을 지정해준 다음 OutPath를 가져와서 DebugSphere을 그려주게 하자.

Enemy.cpp

void AEnemy::BeginPlay()
{
	Super::BeginPlay();
	if (HealthBarWidget)
	{
		HealthBarWidget->SetVisibility(false);
	}

	EnemyController = Cast<AAIController>(GetController());
	if (EnemyController && PatrolTarget)
	{
		FAIMoveRequest MoveRequest;
		MoveRequest.SetGoalActor(PatrolTarget);
		//도착이라고 생각할 거리
		MoveRequest.SetAcceptanceRadius(15.f);
		FNavPathSharedPtr NavPath;
		EnemyController->MoveTo(MoveRequest, &NavPath);
		//& : 복사x -> 참조
		TArray<FNavPathPoint>& PathPoints = NavPath->GetPathPoints();
		for (auto& Point : PathPoints)
		{
			const FVector& Location = Point.Location;
			DrawDebugSphere(GetWorld(), Location, 12.f, FColor::Green, false, 10.f);
		}
	}
}

이렇게 해준다음 BP에서 Patrol Point를 지정해주면 된다.

이렇게 해주고 실행하면 직선이기 때문에 구가 2개만 등장하는 것을 볼 수 있다.

만약 여기서 장애물이나 벽을 추가하면 구가 늘어나게 된다.