前回の記事の Singlecast Dynamic Delegate に Blueprint イベントをバインドする方法を応用(悪用?)して、なんちゃってステートマシンを作ってみた。

ステートマシンというと…

ステートマシンというと、シンプルなものから大仰なものまで色々なパターンを漠然と指してしまうので、今回の目的を小さく絞っておく。

上図のような「enum で定義された複数個のステート(実質、整数のインデックス)に応じて、関数を呼び分けること」を目的とする。
これ、ステートの数が多くなると、Switch が妙に長くなり、イベントグラフがみるみるスパゲティになっていって厄介なので、何とかしたいと思っている人も多いと思う。

まずは、完成品から

使用したアセット: Combat Systems - Constructor (2020年2月の無料コンテンツ)

このロボは以下のようなステート遷移で動いている：

Idleステート
- その場で待機。Idle モーションをする。
- １秒たったら、次のステート(Walk)に遷移する。
Walkステート
- ひたすらまっすぐ歩く。Blendspace 1Dで作った歩きモーションをする。
- ロボの前方にある下向きコーン状の何かが、床から外れたらブレーキをかけ停止する。
- 速度がゼロになったら、次のステート(Turn)へ遷移する。
Turnステート
- 愚直に左に90度回る。左に90度しか回れない。
- ２秒かけて、左に90度回り終わったら、次のステート(Idle)に遷移する。
- 以下、繰り返し(♩)

これらのステート遷移を、Unreal C++ 作ったなんちゃってステートマシンを使って実装している。

Blueprint のようす

コンポーネント

State Binder というのが、なんちゃってステートマシンの役割を担う。(ソースコードなどは後述)
Unreal C++ 製、Actor Component の派生、UStateBinderComponent。

イベントグラフ： Event BeginPlay

BeginEvent BindStates： Event BeginPlay から呼び出されるカスタムイベント。ただ単にスパゲティ化を避けるためだけに別イベントにわけた。
Sequence Then 0： State Binder を総ステート数を指定して初期化。内部では、指定されたステートの数だけ Singlecast Dynamic Delegate を用意する。
Sequence Then 1： State Binder に、Idleステート用のカスタムイベントをバインドする。２つバインドしているのは、ステート切り替え直後に呼び出される OnEnter デリゲートと、そのステート中毎フレーム呼び出される OnUpdate デリゲートがあるから。
- このほかに、ステート切り替えで終了を迎えるステートに送られる OnExit デリゲートも用意したが、今回は使っていない。
Sequence Then 2： Walkステート用のカスタムイベントのバインド。
Sequence Then 3： Turnステート用のカスタムイベントのバインド。

イベントグラフ： Event Tick

State Binder の Update を呼び出している。
この Update が、現在のステートに応じたカスタムイベント(上記 BeginEvent BindStates でバインドされたもの)を呼び出している。

State Binder (UStateBinderComponent) は Tick しない。どうせ Tick するはずのアクタから明示的に呼びだしてもらっている。（こういうやり方でチビチビ Tick の数を削っている）

イベントグラフ／ステートイベント： Idle

OnEnter Idle：他のステートからこのステートに遷移した直後、または初回の Update 呼び出しで呼び出される。
- ステートの経過時間をカウントする変数の初期化。
- アニメーションの更新。Blend 1D に Speed = 0.0 を指定して、Idle モーションを再生させる。
OnUpdate Idle：このステートの毎フレームの処理。単純にステートの経過時間が１秒を超えるのを待ってから、Request Next State で次のステートの Enum 値(≒整数値)を指定している。

イベントグラフ／ステートイベント： Walk

仕組みは Idle ステートと同じなので、イベントグラフのスクショは割愛。

OnEnter Walk：移動速度を 0.0 に初期化.
OnUpdate Walk：下向きコーン状の何かの下のコリジョンを Sphere Trace By Channel でチェック。床がまだあるなら加速、床がないならブレーキ。速度がゼロ以下になったら、次のステート(Turn)へ。

イベントグラフ／ステートイベント： Turn

仕組みは Idle ステートと同じなので、イベントグラフのスクショは割愛。

OnEnter Turn：ステート経過時間のゼロクリア。左に90度回転後の角度を算出して変数に保存。その場回転アニメーションを指定。
OnUpdate Turn：２秒かけてアクタのワールド回転角度を左に90度回す (EaseInOutを使用)。２秒たったら、次のステート(Idle)へ。

UStateBinderComponent (C++)

前回の記事ではデリゲート変数がむき出しで、Blueprint からも好き放題触ることができたが、今回は「配列で管理する必要があったこと」「バインド用の関数を用意したこと」で、UPROPERTY なしの private 変数として作ることができた。
これなら迂闊な事態は発生しないだろう。

UStateBinderComponent.h

ちょっと長いのは、ステート値の int32 版と uint8 版の両方を用意しているから。
※int32 だけだと、Blueprint で Enum 値を渡すときに ToInteger 的なノードが一個挟まって邪魔だったのです。

#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "StateBinderComponent.generated.h"

DECLARE_LOG_CATEGORY_EXTERN(LogStateBinder, Log, All);

DECLARE_DYNAMIC_DELEGATE(FStateBinderEnterSignature);
DECLARE_DYNAMIC_DELEGATE_OneParam(FStateBinderUpdateSignature, float, InDeltaSeconds);
DECLARE_DYNAMIC_DELEGATE(FStateBinderExitSignature);

UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class STATEMACHINE01_API UStateBinderComponent : public UActorComponent
{
	GENERATED_BODY()

public:	
	// Sets default values for this component's properties
	UStateBinderComponent();

protected:
	// Called when the game starts
	virtual void BeginPlay() override;

public:	
	// Called every frame
	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

public: // [RINDERON] blueprint callable interfaces

	// Reserves InNumStates items in state delegate array
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void Initialize(int32 InNumStates);

	// Binds enter state event (integer index version).
	// If you don't bind, just no event will be called.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void BindEnterEventByIntegerIndex(int32 InStateIndex, const FStateBinderEnterSignature& InEnterEvent);

	// Binds update state event (integer index version). (this will be called every time you call Update())
	// If you don't bind, just no event will be called.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void BindUpdateEventByIntegerIndex(int32 InStateIndex, const FStateBinderUpdateSignature& InUpdateEvent);

	// Binds exit state event (integer index version).
	// If you don't bind, just no event will be called.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void BindExitEventByIntegerIndex(int32 InStateIndex, const FStateBinderExitSignature& InExitEvent);

	// Call this function instead of TickComponent, because this component will not tick.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void Update(float InDeltaSeconds);

	// Requests next state.
	// Note that changing state is performed in Update(), not here.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		bool RequestNextStateByIntegerIndex(int32 InNextStateIndex);

	// Stops updates and exit current state.
	// Note that Update() is still running.
	// If you want to PAUSE, you just stop calling Update().
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void Exit() { RequestNextStateByIntegerIndex(InvalidStateIndex); }

	// Returns current state index integer index version
	UFUNCTION(BlueprintPure, Category = "State Binder")
		int32 GetCurrentStateIndexByIntegerIndex() const { return CurrentStateIndex; }

	// Returns number of states
	UFUNCTION(BlueprintPure, Category = "State Binder")
		int32 GetNumStates() const { return NumStates; }

	// Checks if current state index equals to InStateIndex
	UFUNCTION(BlueprintPure, Category = "State Binder")
		bool IsStateIndexEqualsByIntegerIndex(int32 InStateIndex) const { return CurrentStateIndex == InStateIndex; }

	// Returns (InStateIndex>= 0 && InStateIndex < NumStates);
	UFUNCTION(BlueprintPure, Category = "State Binder")
		bool IsValidStateIndexByIntegerIndex(int32 InStateIndex) const { return InStateIndex >= 0 && InStateIndex < NumStates; }

public: // [RINDERON] Byte index version for compatiblility with enum.

		// Binds enter state event (byte (enum) index version).
	// If you don't bind, just no event will be called.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void BindEnterEvent(uint8 InStateIndex, const FStateBinderEnterSignature& InEnterEvent) { BindEnterEventByIntegerIndex((int32)InStateIndex, InEnterEvent); }

	// Binds update state event (byte (enum) index version). (this will be called every time you call Update())
	// If you don't bind, just no event will be called.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void BindUpdateEvent(uint8 InStateIndex, const FStateBinderUpdateSignature& InUpdateEvent) { BindUpdateEventByIntegerIndex((int32)InStateIndex, InUpdateEvent); }

	// Binds exit state event (byte (enum) index version).
	// If you don't bind, just no event will be called.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		void BindExitEvent(uint8 InStateIndex, const FStateBinderExitSignature& InExitEvent) { BindExitEventByIntegerIndex((int32)InStateIndex, InExitEvent); }

	// Requests next state (byte (enum) index version).
	// Note that changing state is performed in Update(), not here.
	UFUNCTION(BlueprintCallable, Category = "State Binder")
		bool RequestNextState(uint8 InNextStateIndex) { return RequestNextStateByIntegerIndex((int32)InNextStateIndex); }

	// Returns current state index (byte (enum) index version).
	UFUNCTION(BlueprintPure, Category = "State Binder")
		uint8 GetCurrentStateIndex() const { return (uint8)GetCurrentStateIndexByIntegerIndex(); }

	// Checks if current state index equals to InStateIndex (byte (enumn) index version).
	UFUNCTION(BlueprintPure, Category = "State Binder")
		bool IsStateIndexEquals(uint8 InStateIndex) const { return IsStateIndexEqualsByIntegerIndex((int32)InStateIndex); }

	// Returns (CurrentStateIndex >= 0 && CurrentStateIndex < NumStates);
	UFUNCTION(BlueprintPure, Category = "State Binder")
		bool IsValidStateIndex(int32 InStateIndex) const { return IsValidStateIndexByIntegerIndex((int32)InStateIndex); }

private: // [RINDERON] internal properties

	static const int32 InvalidStateIndex = -1;

	int32 NumStates = 0;
	int32 CurrentStateIndex = InvalidStateIndex; // initial value must be invalid.
	int32 NextStateIndex = 0; // set zero to fire changing to state 0 at the top of Update().

	TArray<FStateBinderEnterSignature> EnterDelegateArray;
	TArray<FStateBinderUpdateSignature> UpdateDelegateArray;
	TArray<FStateBinderExitSignature> ExitDelegateArray;
};

UStateBinderComponent.cpp

ちょっとした要点としては、ステートの切り替えを RequestNextState() 呼び出し内で処理せずに、Update() の冒頭で行っていることだろうか。
RequestNextState() が Tick の流れで呼び出されるとは限らないので(※)。

※Tick の流れで呼び出されるとは限らない
コリジョンヒット時に呼び出されたり、アニメーションのNotify経由で呼び出されたり、Game Mode や Game State から呼び出されたり。
UStateBinderComponent::Update() の実行開始～ステートイベントの処理～Update() に処理が戻ってくるまでの間 「以外に」 ステートの変更が発生すると、想定外の動作を引き起こすことが多々ある。これは UE4 に限らず、すべてのゲームプログラムでよくある問題。

#include "StateBinderComponent.h"

DEFINE_LOG_CATEGORY(LogStateBinder);

// Sets default values for this component's properties
UStateBinderComponent::UStateBinderComponent()
{
	// Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
	// off to improve performance if you don't need them.
	// [RIDNERON] PrimaryComponentTick.bCanEverTick = true;
	/* [RINDERON] */ PrimaryComponentTick.bCanEverTick = false; // this component will not tick! call Update() manually.
}

// BeginPlay() は無改変なので割愛
// TickComponent() も無改変なので割愛

////////////////////////////////////////////////////////////////////////////////
// [RINDERON]

void UStateBinderComponent::Initialize(int32 InNumStates)
{
	if (InNumStates > 0)
	{
		EnterDelegateArray.SetNum(InNumStates);
		UpdateDelegateArray.SetNum(InNumStates);
		ExitDelegateArray.SetNum(InNumStates);

		NumStates = InNumStates;
		CurrentStateIndex = InvalidStateIndex; // initial value must be invalid.
		NextStateIndex = 0; // set zero to fire changing to state 0 at the top of Update().
	}
	else
	{
		EnterDelegateArray.Empty();
		UpdateDelegateArray.Empty();
		ExitDelegateArray.Empty();

		NumStates = 0;
		CurrentStateIndex = InvalidStateIndex;
		NextStateIndex = InvalidStateIndex;
	}
}

void UStateBinderComponent::BindEnterEventByIntegerIndex(int32 InStateIndex, const FStateBinderEnterSignature& InEnterEvent)
{
	if (EnterDelegateArray.IsValidIndex(InStateIndex))
	{
		EnterDelegateArray[InStateIndex] = InEnterEvent;
	}
}

void UStateBinderComponent::BindUpdateEventByIntegerIndex(int32 InStateIndex, const FStateBinderUpdateSignature& InUpdateEvent)
{
	if (UpdateDelegateArray.IsValidIndex(InStateIndex))
	{
		UpdateDelegateArray[InStateIndex] = InUpdateEvent;
	}
}

void UStateBinderComponent::BindExitEventByIntegerIndex(int32 InStateIndex, const FStateBinderExitSignature& InExitEvent)
{
	if (ExitDelegateArray.IsValidIndex(InStateIndex))
	{
		ExitDelegateArray[InStateIndex] = InExitEvent;
	}
}

void UStateBinderComponent::Update(float InDeltaSeconds)
{
	// change state
	if (CurrentStateIndex != NextStateIndex)
	{
		// exit current state
		if (ExitDelegateArray.IsValidIndex(CurrentStateIndex))
		{
			const FStateBinderExitSignature& onExitState = ExitDelegateArray[CurrentStateIndex];
			onExitState.ExecuteIfBound();
		}

		// enter next state
		if (UpdateDelegateArray.IsValidIndex(NextStateIndex))
		{
			FStateBinderEnterSignature& onEnterState = EnterDelegateArray[NextStateIndex];
			onEnterState.ExecuteIfBound();
		}

		CurrentStateIndex = NextStateIndex;
	}

	// update state
	if (UpdateDelegateArray.IsValidIndex(CurrentStateIndex))
	{
		FStateBinderUpdateSignature& onUpdateState = UpdateDelegateArray[CurrentStateIndex];
		onUpdateState.ExecuteIfBound(InDeltaSeconds);
	}
}

bool UStateBinderComponent::RequestNextStateByIntegerIndex(int32 InNextStateIndex)
{
	if (InNextStateIndex >= 0 && InNextStateIndex < NumStates && CurrentStateIndex != InNextStateIndex)
	{
		NextStateIndex = InNextStateIndex;
		return true;
	}
	return false;
}

以上です。

自分的には、今後非常に便利に使える気がしている。