【UE5】第二回 ミニゲーム制作で学ぶUnrealC++ 〜キャラクター・ゲーム実装 編〜

private:

・・・

	/** MappingContext */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	TObjectPtr<UInputMappingContext> DefaultMappingContext;

	/** Jump Input Action */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	TObjectPtr<UInputAction> JumpAction;

	/** Rotate L Input Action */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	TObjectPtr<UInputAction> RotateLAction;
	
	/** Rotate R Input Action */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	TObjectPtr<UInputAction> RotateRAction;

	/** Squat Input Action */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	TObjectPtr<UInputAction> SquatAction;

・・・

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

	// Add Input Mapping Context
	if (const APlayerController* PlayerController = Cast<APlayerController>(Controller))
	{
		if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
		{
			Subsystem->AddMappingContext(DefaultMappingContext, 0);
		}
	}

・・・略・・・

}

void ACatCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent);
	if (EnhancedInputComponent == nullptr)
	{
		UE_LOG(LogTemplateCharacter, Error, TEXT("'%s' Failed to find an Enhanced Input component! This template is built to use the Enhanced Input system. If you intend to use the legacy system, then you will need to update this C++ file."), *GetNameSafe(this));
		return;
	}

	// Jumping
	EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Started, this, &ACatCharacter::InputJump);
	EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &ACharacter::StopJumping);

	// Rotate
	EnhancedInputComponent->BindAction(RotateLAction, ETriggerEvent::Started, this, &ACatCharacter::InputRotateL);
	EnhancedInputComponent->BindAction(RotateRAction, ETriggerEvent::Started, this, &ACatCharacter::InputRotateR);

	// Squat
	EnhancedInputComponent->BindAction(SquatAction, ETriggerEvent::Started, this, &ACatCharacter::InputSquat);
	EnhancedInputComponent->BindAction(SquatAction, ETriggerEvent::Completed, this, &ACatCharacter::InputSquatCanceled);
}

・・・

// === ジャンプの例

void ACatCharacter::InputJump()
{
	// Runステート時のみが対象
	if (GetCurrentState() != ECatState::Run)
	{
		return;
	}

	// ステート変更
	ChangeState(ECatState::Jump);
	Super::Jump();
}

/**
 * ねこステート定義
 */
UENUM(BlueprintType)
enum class ECatState : uint8
{
	None,
	Wait,       // 待機
	Run,        // 走る
	Jump,       // ジャンプ
	RotateL,    // 左回転
	RotateR,    // 右回転
	Squat,      // しゃがむ
	TurnCorner, // 角を曲がる
	Dead,       // 死亡
};

private:
	/** ステートマシン */
	TUniquePtr<ZStateMachine<ACatCharacter>> StateMachine;

	/** 現在のステート変更処理 */
	void ChangeState(ECatState State) const;

・・・略・・・

	/**
	 * State: 待機
	 */
	class StateWait : public ZStateBase<ACatCharacter>
	{
	public:
		virtual void OnBegin(ACatCharacter* StateOwner) override;
		virtual void OnTick(ACatCharacter* StateOwner, float DeltaTime) override;
		virtual void OnEnd(ACatCharacter* StateOwner) override;
	};

void ACatCharacter::StateWait::OnBegin(ACatCharacter* StateOwner)
{
	FStateBase::OnBegin(StateOwner);
}

void ACatCharacter::StateWait::OnTick(ACatCharacter* StateOwner, float DeltaTime)
{
	FStateBase::OnTick(StateOwner, DeltaTime);

	// 移動準備ができたか？
	if (StateOwner->bIsReadyMove)
	{
		StateOwner->ChangeState(ECatState::Run);
	}
}

void ACatCharacter::StateWait::OnEnd(ACatCharacter* StateOwner)
{
	FStateBase::OnEnd(StateOwner);
}

void ACatCharacter::BeginPlay()
{

・・・略・・・

	// ステート初期化
	StateMachine = MakeUnique<FStateMachine<ACatCharacter>>(this);
	StateMachine->Add<StateWait>(static_cast<int>(ECatState::Wait));
	StateMachine->Add<StateRun>(static_cast<int>(ECatState::Run));
	StateMachine->Add<StateJump>(static_cast<int>(ECatState::Jump));
	StateMachine->Add<StateRotate>(static_cast<int>(ECatState::RotateL));
	StateMachine->Add<StateRotate>(static_cast<int>(ECatState::RotateR));
	StateMachine->Add<StateSquat>(static_cast<int>(ECatState::Squat));
	StateMachine->Add<StateTurnCorner>(static_cast<int>(ECatState::TurnCorner));
	StateMachine->Add<StateDead>(static_cast<int>(ECatState::Dead));
	StateMachine->OnBegin(static_cast<int>(ECatState::Wait));
}

void ACatCharacter::Tick(float DeltaTime)
{

・・・略・・・

	// ステート更新
	StateMachine->OnTick(DeltaTime);
}

ECatState ACatCharacter::GetCurrentState() const
{
	if (StateMachine == nullptr)
	{
		return ECatState::None;
	}
	return static_cast<ECatState>(StateMachine->GetCurrentStateId());
}

void ACatCharacter::ChangeState(ECatState State) const
{
	StateMachine->ChangeState(static_cast<int>(State));
}

		// 曲がるポイントに到着したかのチェック
		constexpr float AllowDistance = 50.0f;
		const auto CurrentLocation = StateOwner->GetActorLocation();
		const auto DiffForwardLocation = (StateOwner->StartTurnCornerPoint - CurrentLocation).GetAbs() * StateOwner->GetActorForwardVector();
		if (DiffForwardLocation.Length() <= AllowDistance)
		{
			bIsArriveTurnCorner = true;

			// プレイヤーを回転させる
			const FVector NewActorLocation = CurrentLocation + DiffForwardLocation;
			StateOwner->SetActorLocation(NewActorLocation);
			const FRotator NewActorRotator = StateOwner->GetActorRotation() + StateOwner->ChangeTurnCornerRotator;
			StateOwner->SetActorRotation(NewActorRotator);
		}

// Copyright (c) 2024, CatRunner All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Animation/AnimInstance.h"
#include "CatAnimInstance.generated.h"

/**
 * ねこ: AnimInstance
 */
UCLASS()
class CATRUNNER_API UCatAnimInstance : public UAnimInstance
{
	GENERATED_BODY()

public:
	/** update event */
	virtual void NativeUpdateAnimation(float DeltaSeconds) override;

protected:
	UPROPERTY(BlueprintReadOnly, Category = "CatRunner: Cat")
	bool bIsRunState;

	UPROPERTY(BlueprintReadOnly, Category = "CatRunner: Cat")
	bool bIsJumpState;

	UPROPERTY(BlueprintReadOnly, Category = "CatRunner: Cat")
	bool bIsRotateLState;

	UPROPERTY(BlueprintReadOnly, Category = "CatRunner: Cat")
	bool bIsRotateRState;

	UPROPERTY(BlueprintReadOnly, Category = "CatRunner: Cat")
	bool bIsSquatState;

};

// Copyright (c) 2024, CatRunner All Rights Reserved.


#include "Cat/CatAnimInstance.h"
#include "Cat/CatCharacter.h"

void UCatAnimInstance::NativeUpdateAnimation(float DeltaSeconds)
{
	Super::NativeUpdateAnimation(DeltaSeconds);

	// プロパティ初期化
	bIsRunState = false;
	bIsJumpState = false;
	bIsRotateLState = false;
	bIsRotateRState = false;
	bIsSquatState = false;

	// プレイヤーのステートをチェック
	const auto player = Cast<ACatCharacter>(GetOwningActor());
	if (player == nullptr)
	{
		return;
	}
	const ECatState CurrentState = player->GetCurrentState();
	switch (CurrentState)
	{
	case ECatState::Run:
		bIsRunState = true;
		break;
	case ECatState::Jump:
		bIsJumpState = true;
		break;
	case ECatState::RotateL:
		bIsRotateLState = true;
		break;
	case ECatState::RotateR:
		bIsRotateRState = true;
		break;
	case ECatState::Squat:
		bIsSquatState = true;
		break;
	default:
		break;
	}
}

/**
 * RunGameレベルクラス
 */
UCLASS()
class ARunGameLevelScript : public ALevelScriptActor
{
	GENERATED_BODY()

public:
	ARunGameLevelScript();

protected:
	virtual void BeginPlay() override;
	virtual void Tick(float DeltaSeconds) override;
	
・・・

/**
 * RunGameレベルステート定義
 */
UENUM(BlueprintType)
enum class ERunGameState : uint8
{
	None,
	Ready,  // 準備中
	Play,   // プレイ中
	End,    // 終了
	Result, // リザルト
};

// Copyright (c) 2024, CatRunner All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "StageLevelTableRow.generated.h"

/**
 * ステージレベル情報
 */
USTRUCT(BlueprintType)
struct FStageLevelTableRow : public FTableRowBase
{
	GENERATED_BODY()

	/** プレイヤーに加算する前進速度 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	float AddPlayerForwardSpeed;

	/** 1つの道に含まれる床の数 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	uint8 RoadFloorCount;

	/** 取得アイテム生成確率(%) */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	uint8 GeneratePickupPercent;

	/** 取得アイテム最大生成数 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	uint8 MaxGeneratePickupCount;

	/** ギミック最小生成数 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	uint8 MinGenerateGimmickCount;

	/** ギミック最大生成数 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	uint8 MaxGenerateGimmickCount;
};

	/** ステージレベルテーブル */
	UPROPERTY(EditAnywhere)
	TObjectPtr<UDataTable> StageLevelTable;

FStageLevelTableRow* ARunGameLevelScript::GetStageLevelInfo(int StageLevel) const
{
	const FString Context;
	return StageLevelTable->FindRow<FStageLevelTableRow>(FName(FString::FromInt(StageLevel)), Context);
}

・・・

private:
	/** ステージ床アクタ */
	UPROPERTY(EditAnywhere)
	TSubclassOf<AStageFloor> StageFloor;

	/** ステージ床アクタ(左L字) */
	UPROPERTY(EditAnywhere)
	TSubclassOf<AStageFloor> StageFloorL;

	/** ステージ床アクタ(右L字) */
	UPROPERTY(EditAnywhere)
	TSubclassOf<AStageFloor> StageFloorR;

	/** 曲がるときに出すボーナスピックアップ */
	UPROPERTY(EditAnywhere)
	TSubclassOf<APickup> TurnCornerBonusPickup;

	/** 取得アイテム生成情報テーブル */
	UPROPERTY(EditAnywhere)
	TArray<FPickupGenerateInfo> PickupGenerateTable;

	/** ギミック(現状1種類) */
	UPROPERTY(EditAnywhere)
	TSubclassOf<AGimmick> Gimmick;
	
・・・

TObjectPtr<AStageFloor> AStageGenerator::GenerateFloor(const FVector& SpawnLocation,  const FRotator& SpawnRotator, const EStageFloorType StageFloorType)
{
	// 床の種類からアクタを取得
	TSubclassOf<AStageFloor> StageFloorActor = nullptr;
	switch (StageFloorType)
	{
	case EStageFloorType::Normal:
		StageFloorActor = StageFloor;
		break;
	case EStageFloorType::Left:
		StageFloorActor = StageFloorL;
		break;
	case EStageFloorType::Right:
		StageFloorActor = StageFloorR;
		break;
	default:
		break;
	}
	if (StageFloorActor == nullptr)
	{
		return nullptr;
	}

	// アクタを生成
	FActorSpawnParameters SpawnParams;
	SpawnParams.Owner = this;
	SpawnParams.Instigator = GetInstigator();
	UWorld* const World = GetWorld();
	return World->SpawnActor<AStageFloor>(StageFloorActor, SpawnLocation, SpawnRotator, SpawnParams);
}

ACatCharacter::ACatCharacter()
	:CurrentMoveForwardSpeed(0.0f)
	,StartTurnCornerPoint(FVector::ZeroVector)
	,ChangeTurnCornerRotator(FRotator::ZeroRotator)
	,bIsReadyMove(false)
	,bIsPushSquat(false)
{
	// Set size for collision capsule
	GetCapsuleComponent()->InitCapsuleSize(50.f, 50.0f);
	GetCapsuleComponent()->OnComponentBeginOverlap.AddDynamic(this, &ACatCharacter::OnOverlapBegin); // setup overlap event.
		
・・・

}

・・・

void ACatCharacter::OnOverlapBegin(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
	UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
	// イベント発行
	if (OnHitActorDelegate.IsBound())
	{
		OnHitActorDelegate.Execute(this, OtherActor);
	}
}

FHitInfo ABlockGimmick::OnHit(AActor* HitActor)
{
	// エフェクト、サウンド再生
	const FVector PlayerLocation = HitActor->GetActorLocation();
	if (PlayerDestroyEffect != nullptr)
	{
		UNiagaraFunctionLibrary::SpawnSystemAtLocation(GetWorld(), PlayerDestroyEffect, PlayerLocation);
	}
	if (PlayerDestroySound != nullptr)
	{
		UCatRunnerGameInstance::GetAudioService()->PlaySe3d(PlayerDestroySound, PlayerLocation);
	}

	// ヒット対象を破棄する
	FHitInfo HitInfo;
	HitInfo.bIsTargetDestroy = true;
	return HitInfo;
}

void UHitDetectManager::Initialize(ACatCharacter* Player) const
{
	// プレイヤーに監視イベントを設定
	Player->OnHitActorDelegate.BindLambda([this](ACatCharacter* Player, AActor* HitActor)
	{
		OnDetectedHitPlayer(Player, HitActor);
	});
}

void UHitDetectManager::OnDetectedHitPlayer(ACatCharacter* Player, AActor* HitActor)
{
	IHitObjectInterface* HitObject = Cast<IHitObjectInterface>(HitActor);
	if (HitObject == nullptr)
	{
		return;
	}

	// ヒット情報によって処理を行う
	const FHitInfo HitInfo = HitObject->OnHit(Player);

	// スコアの加算
	if (HitInfo.AddScore != 0)
	{
		const auto LevelScriptActor = UGameplayStatics::GetActorOfClass(Player->GetWorld(), ARunGameLevelScript::StaticClass());
		const auto RunGameLevelScript = Cast<ARunGameLevelScript>(LevelScriptActor);
		if (RunGameLevelScript != nullptr)
		{
			RunGameLevelScript->AddPickupScore(HitInfo.AddScore);
		}
	}

	// 死亡させるか？
	if (HitInfo.bIsTargetDestroy)
	{
		Player->OnDie();
	}

	// 回転させるか？
	if (HitInfo.ChangeTurnCornerRotator != FRotator::ZeroRotator)
	{
		Player->OnTurnCorner(HitInfo.ChangeTurnCornerRotator, HitActor->GetActorLocation());
	}
}