UE5 Finite State Machine - Part 2

In my previous post, we began setting up a finite state machine in C++ for a farm plot object in a game. Here, we will add some content to the farm plot itself so that we may be able to view changes when they occur.

Farmplot Art

If you haven't already, start by importing 5 different ground textures from quixel bridge (mega scans) into your project. Pick something that corelates to the name of our state. We are then going to create a scalable way for our FSM to get the correct texture to use to render our farmplot. To do this, we create a data table based on a custom role we'll create in C++. This is a struct derived from FTableRowBase. All we need is a header file in the public folder. It's easiest for me to create it in my VS Code window on the left. This struct will consist of 2 uproperties. First a display name being of type FString. Second, a material of type UMaterialInstance. Once finished it should look like this:

#pragma once

#include "CoreMinimal.h"
#include "Engine/DataTable.h"

#include "FarmplotMeshMaterialTableRow.generated.h"

/**
 * 
 */
USTRUCT(BlueprintType)
struct FSM_BLOG_API FFarmplotMeshMaterialTableRow : public FTableRowBase
{
	GENERATED_BODY()
public:
	
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Resources)
	FString DisplayName;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Resources)
	UMaterialInstance* Material;
};

We then create a datatable based on this datatable row. I've named my datatable FarmplotMeshMaterials. In this datatable, there should be a row for each of our farm plot states, each named the same. This row name will be used to find the correct material to show. This creates a central location for which material to use, instead of searching the entire project and hard coding the material in source.

Alright we have our art assets, and our datatable, what's next? Well lets give our farm plot a mesh to draw these textures on. In the farm plot class, we already have our mesh in the class, but it never gets assigned. Let's fix that. In the header file, add a UDataTable pointer named plotMats to hold a reference to our data table in the class. In the CPP file, fill out the constructor like so:

AFarmplot::AFarmplot()
{
	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	groundMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Ground Mesh"));
	groundMesh->SetupAttachment(RootComponent);
	ConstructorHelpers::FObjectFinder<UStaticMesh> plane(TEXT("/Engine/BasicShapes/Plane"));
	groundMesh->SetStaticMesh(plane.Object);
	groundMesh->SetRelativeScale3D(*(new FVector(2.0,2.0,1.0)));

	ConstructorHelpers::FObjectFinder<UDataTable> plotMatsFinder(TEXT("DataTable'/Game/_Game/FarmplotMeshMaterials.FarmplotMeshMaterials'"));
	plotMats = plotMatsFinder.Object;

	groundMesh->SetMaterial(0, plotMats->FindRow<FFarmplotMeshMaterialTableRow>(TEXT("Placed"), "")->Material);
}

Be sure to include references to the appropriate header files. Now, we can drag the C++ class into our editor and it'll create an instance of the farmplot class for us. you may need to raise it above the ground to fully see it.

To interact with the FSM, we have to be able to interact with the farm plot object on an individual basis. Each farmplot has their own copy of the FSM so that way each farmplot can be at different states. To do this, we need to be able to interact with an individual plot, and indicate to the player which plot is being targeted. While we're in the editor, lets create a highlight material that'll display when the player is in range, and which plot is being targeted.

Create a new material and call it m_Highlight. In the editor, on the left, set the blend mode to additive for the material. Then add a single parameter and set it to the highlight color you wish. I set mine to yellow.

Close the material editor and right click on the material in your content browser. You want to create a material instance from this material. In our datatable, create a new row for the highlight.

Looking at an object in game isn't something that we only do we farm plots. We do this with trees, buildings, doors, and a whole plethora of other things. Each doing something different when looked at. To capture this, create an interface called Interactable and give it two methods, LookAt and LookAway. UE interfaces written in C++ are not straightforward so here is it's structure below:

#pragma once

#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "Interactable.generated.h"

class IInteractable
{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category = Interaction)
    void LookAt();

    UFUNCTION(Blueprintcallable, BlueprintNativeEvent, Category = Interaction)
    void LookAway();

    UFUNCTION(Blueprintcallable, BlueprintNativeEvent, Category = Interaction)
    void Interact();
};

UINTERFACE(MinimalAPI)
class UInteractable: public UInterface
{
    GENERATED_BODY()
};

So lets have our farm plot now implement this new interface

#include "Interactable.h"

#include "Farmplot.generated.h"

UCLASS(BlueprintType)
class FSM_BLOG_API AFarmplot : public AActor, public IInteractable
{
...
public:	
	// Called every frame
	virtual void Tick(float DeltaTime) override;

	void LookAt_Implementation() override;

	void LookAway_Implementation() override;

    void Interact_Implementation() override;
};

#include "Farmplot.h"
...
void AFarmplot::LookAt_Implementation()
{

}

void AFarmplot::LookAway_Implementation()
{
	
}

void AFarmplot::Interact_Implementation()
{

}

Now that we are implementing the interactable interface, we can show the highlight mesh when it is looked at and hide it when it is not looked at. Lets add the mesh and code the logic. First, add a new static mesh into the header file and call it "highlightMesh".

UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category=Resources, meta=(AllowPrivateAccess="true"))

UStaticMeshComponent* highlightMesh;

In our farmplot CPP, we need to define our highlight mesh, then toggle the visibility in our IInteractable methods. Make sure that the highlight mesh ignores collisions.

AFarmplot::AFarmplot()
{
    PrimaryActorTick.bCanEverTick = true;
...
    highlightMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Highlight Mesh"));
	highlightMesh->SetupAttachment(groundMesh);
	highlightMesh->SetStaticMesh(plane.Object);
    highlightMesh->SetMaterial(0, plotMats->FindRow<FFarmplotMeshMaterialTableRow>(TEXT("Highlight"),"")->Material);

	FVector* highlightLocation = new FVector(groundMesh->GetRelativeTransform().GetLocation());
	highlightLocation->Z += .5;

	highlightMesh->SetRelativeLocation_Direct(*highlightLocation);
	highlightMesh->SetVisibility(false);
	highlightMesh->SetCollisionEnabled(ECollisionEnabled::Type::NoCollision);
}
...
void AFarmplot::LookAt_Implementation()
{
	highlightMesh->SetVisibility(true);
}

void AFarmplot::LookAway_Implementation()
{
	highlightMesh->SetVisibility(false);
}

This is great and all but nothing still calls these methods. Lets fix that now. This is going to require some changes in the third person character blueprint. We'll cover this in my next post.