【UE5】UnrealC＋＋でプレイヤーとAIの移動処理を作成してみた

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/FloatingPawnMovement.h"
#include "MyFloatingPawnMovement.generated.h"

// 入力方向に移動し、徐々にその方向に振り向かせる
UCLASS(meta = (BlueprintSpawnableComponent))
class INTERFACETEST_API UMyFloatingPawnMovement : public UFloatingPawnMovement
{
	GENERATED_BODY()

public:
	virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

protected:
	virtual void BeginPlay() override;

	// 振り向き速度
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	float rotationSpeed = 5.0f;

	// 衝突による回転や移動を防ぐために初期値を保存しておく
	FRotator startRotation;
	FVector startPosition;
};

#include "MyFloatingPawnMovement.h"

void UMyFloatingPawnMovement::BeginPlay()
{
	// 衝突時の移動と回転を制限するため開始時の状態を保存
	startPosition = PawnOwner->GetActorLocation();
	startRotation = PawnOwner->GetActorRotation();
}

void UMyFloatingPawnMovement::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
	// FloatingMovementのTick ポーンの移動処理
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

	// ポーンを入力方向に時間をかけて振り向かせる
	auto movement = PawnOwner->GetLastMovementInputVector();

	// 入力がある時だけ回転
	if (!movement.IsZero())
	{
		auto currentRot = PawnOwner->GetActorRotation();
		auto targetRot = movement.Rotation();
		PawnOwner->SetActorRotation(FMath::RInterpTo(currentRot, targetRot, DeltaTime, rotationSpeed));
	}

	// 衝突時のZ軸移動とY軸回転の制限
	auto currentPosition = PawnOwner->GetActorLocation();
	if (currentPosition.Z != startPosition.Z)
	{
		PawnOwner->SetActorLocation(FVector(currentPosition.X, currentPosition.Y, startPosition.Z));
	}

	auto currentRotation = PawnOwner->GetActorRotation();
	if (currentRotation.Pitch != startRotation.Pitch)
	{
		PawnOwner->SetActorRotation(FRotator(startRotation.Pitch, currentRotation.Yaw, currentRotation.Roll));
	}
}

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "MyPawn.h"
#include "MyPlayerController.generated.h"


UCLASS()
class INTERFACETEST_API AMyPlayerController : public APlayerController
{
	GENERATED_BODY()

protected:
	virtual void BeginPlay() override;

	// 入力イベントに移動関数を登録
	virtual void SetupInputComponent() override;

	// 入力によってポーンを移動
	virtual void MoveForward(float value);
	virtual void MoveRight(float value);
};

#include "MyPlayerController.h"

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

void AMyPlayerController::SetupInputComponent()
{
	Super::SetupInputComponent();

	InputComponent->BindAxis(
		"MoveForward",
		this,
		&AMyPlayerController::MoveForward);

	InputComponent->BindAxis(
		"MoveRight",
		this,
		&AMyPlayerController::MoveRight);
}

void AMyPlayerController::MoveForward(float value)
{
	GetPawn()->AddMovementInput(FVector::ForwardVector * value);
}

void AMyPlayerController::MoveRight(float value)
{
	GetPawn()->AddMovementInput(FVector::RightVector * value);
}

#pragma once

#include "CoreMinimal.h"
#include "AIController.h"
#include "MyAIController.generated.h"

UCLASS()
class INTERFACETEST_API AMyAIController : public AAIController
{
	GENERATED_BODY()

protected:
	virtual void BeginPlay() override;
};

#include "MyAIController.h"
#include <BehaviorTree/BlackboardComponent.h>
#include <Kismet/GameplayStatics.h>

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

	// BlackboardにプレイヤーをTaragetActorとして登録
	auto pBlackBoard = GetBlackboardComponent();
	if (pBlackBoard)
	{
		pBlackBoard->SetValueAsObject(TEXT("TargetActor"), UGameplayStatics::GetPlayerPawn(this, 0));
	}
}

#pragma once

#include "CoreMinimal.h"
#include <BehaviorTree/Tasks/BTTask_BlackboardBase.h>
#include <NavigationSystem.h>
#include "BT_CustomMoveTo.generated.h"

// 経路探索を行いPawnのAddInputMovementで移動させる
UCLASS()
class INTERFACETEST_API UBT_CustomMoveTo : public UBTTask_BlackboardBase
{
	GENERATED_BODY()
public:
	UBT_CustomMoveTo();

private:
	virtual EBTNodeResult::Type ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) override;

protected:
	virtual void TickTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, float DeltaSeconds) override;

	virtual FVector CalcMovement(const APawn* pOwner);

	APawn* pTarget;

	UNavigationSystemV1* navSys;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (ClampMin = "0.0", UIMin = "0.0"))
	float acceptableRadius = 50.0f;
};

#include "BT_CustomMoveTo.h"
#include <AIController.h>
#include <NavigationPath.h>
#include <BehaviorTree/BlackboardComponent.h>
#include <BehaviorTree/Blackboard/BlackboardKeyType_Object.h>
#include <VisualLogger/VisualLogger.h>

UBT_CustomMoveTo::UBT_CustomMoveTo() :Super()
{
	NodeName = TEXT("CustomMoveTo");
  bNotifyTick = true;
	navSys = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());

	// ブラックボードから渡されるターゲットのクラスをPawnに限定
	BlackboardKey.AddObjectFilter(this, GET_MEMBER_NAME_CHECKED(UBT_CustomMoveTo, BlackboardKey), APawn::StaticClass());
}

EBTNodeResult::Type UBT_CustomMoveTo::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
  // Targetを取得
	auto pBlackboard = OwnerComp.GetBlackboardComponent();;
	auto pKeyValue = pBlackboard->GetValue<UBlackboardKeyType_Object>(BlackboardKey.GetSelectedKeyID());
	pTarget = Cast<APawn>(pKeyValue);

　// Tickで移動処理するのでInProgressを返す
	return EBTNodeResult::InProgress;
}

void UBT_CustomMoveTo::TickTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, float DeltaSeconds)
{
    auto pController = OwnerComp.GetAIOwner();
	auto pOwner = pController->GetPawn();

	// ターゲットに到達しているのかの判定
	auto distance = pOwner->GetActorLocation() - pTarget->GetActorLocation();
	if (distance.SquaredLength() > acceptableRadius * acceptableRadius)
	{
		auto movement = CalcMovement(pOwner);

		if (!movement.IsZero())
		{
			pOwner->AddMovementInput(movement);
		}
	}
	else
	{
		// タスクの正常終了を通知
		FinishLatentTask(OwnerComp, EBTNodeResult::Succeeded);
	}

    return;
}

FVector UBT_CustomMoveTo::CalcMovement(const APawn* pOwner)
{
	// NavigationMeshを用いて移動経路を探索
	auto pPath = navSys->FindPathToActorSynchronously(GetWorld(), pOwner->GetActorLocation(), pTarget);
	if (!pPath) return FVector::Zero();

	auto& pathPoints = pPath->PathPoints;

	if (pathPoints.Num() >= 2)
	{
		// 自身の座標から初めの地点への方向を返す
		auto dir = pathPoints[1] - pathPoints[0];
		dir.Normalize();
		return dir;
	}
	else
	{
		return FVector::Zero();
	}
}