The game mode is going to be fairly simple. We are going to a add a few member variables that will hold the current state of the game such as game speed, game level, and the number of coins needed to increase the game speed. Navigate to BountyDashGameMode.h and add the following code:

UCLASS(minimalapi)
class ABountyDashGameMode : public AGameMode
{
GENERATED_BODY()

UPROPERTY()
float gameSpeed;

UPROPERTY()
int32 gameLevel;

As you can see, we have two private member variables gameSpeed and gameLevel. These are private as we wish no other object to be able to modify the contents of these values. You will also note that the class has been specified with minimalapi. This specifier effectively informs the engine that other code modules will not need information from this object outside of the class type. This means that you will be able to cast to this class type but functions cannot be called within other modules. This is specified as a way to optimize compile times as no module outside of this project API will require interactions with our game mode.

Next, we declare the public functions and members we will be using within our game mode. Add the following code to the ABountyDashGameMode class definition:

public:
ABountyDashGameMode();

    void CharScoreUp(unsigned int charScore);

    UFUNCTION()
    float GetInvGameSpeed();

    UFUNCTION()
    float GetGameSpeed();

    UFUNCTION()
    int32 GetGameLevel();

The CharScroreUp()function takes in the player's current score (held by the player) and changes game values based on that score. This means we are able to make the game more difficult, as the player scores more points. The next three functions are simply the accessor methods we can use to get the private data of this class in other objects.

Next, we need to declare our protected members we exposed to be EditAnywhere, so we may adjust these from the editor for testing purposes.

protected:

UPROPERTY(EditAnywhere, BlueprintReadOnly)
int32 numCoinsForSpeedIncrease;

UPROPERTY(EditAnywhere, BlueprintReadWrite)
float gameSpeedIncrease;

};

The numCoinsForSpeedIncrease variable will determine how many coins it takes to increase the speed of the game and the gameSpeedIncrease value will determine how much faster the objects move when the numCoinsForSpeedIncrease value has been met.

Let's begin add some definitions to the BountyDashGameMode functions. They will be very simple at this point. Let's start by providing some default values for our member variables within the constructor and by assigning the class to be used for our default pawn. Add the definition for the ABountyDashGameMode constructor:

ABountyDashGameMode::ABountyDashGameMode()
{
    // set default pawn class to our ABountyDashCharacter
    DefaultPawnClass = ABountyDashCharacter::StaticClass();

    numCoinsForSpeedIncrease = 5;
    gameSpeed = 10.0f;
    gameSpeedIncrease = 5.0f;
    gameLevel = 1;
}

Here, we are setting the default pawn class by calling StaticClass() on ABountyDashCharacter. As we have just referenced the ABountyDashCharacter type, ensure that #include "BountyDashCharacter.h" is add to the BountyDashGameMode.cpp include list. The StaticClass() function is provided by default for all objects and returns the class type information of the object as a UClass*. We then establish some default values for member variables. The player will have to pick up five coins to increase level, the game speed is set to 10.0f (10m/s) and the game will speed up by 5.0f (5m/s) every time the coin quota is reached. Next, let's add a definition for the CharScoreUp() function:

void
ABountyDashGameMode::CharScoreUp(unsigned int charScore)
{
    if (charScore != 0 &&
       charScore % numCoinsForSpeedIncrease == 0)
    {
        gameSpeed += gameSpeedIncrease;
        gameLevel++;
    }
}

This function is quite self-explanatory. The character's current score is passed into the function. We then check that the character's score is not currently 0 and that if the remainder of our character score is 0 after being divided by the number of coins needed for a speed increase, that is, if it divided equally thus the quota has been reached. We then increase the game speed by the gameSpeedIncrease value and then increment the level.

The last thing we need to add is the accessor methods described earlier. They do not require too much explanation short of the GetInvGameSpeed() function. This function will be used by objects that wish to be pushed down the x-axis at the game speed:

float
ABountyDashGameMode::GetInvGameSpeed()
{
    return -gameSpeed;
}

float
ABountyDashGameMode::GetGameSpeed()
{
    return gameSpeed;
}

int32 ABountyDashGameMode::GetGameLevel()
{
    return gameLevel;
}

The ABountyDashGame mode now contains information and functionality that will be required by most of the BountyDash objects we create going forward. We need to create a light-weight method to retrieve our custom game mode ensuring that the type of information is preserved. We can do this by creating a template function that will take in a world context and return the correct game mode handle. Traditionally, we could just use a direct cast to ABountyDashGameMode; however, this would require including BountyDashGameMode.h in BountyDash.h. As not all of our objects will require knowledge of the game mode, this is wasteful. Navigate to the BoutyDash.h file now. You will be presented with the following:

#pragma once

#include "Engine.h"

What currently exists in the file is very simple, #pragma once has again been used to ensure the compiler only builds and includes the file once. Then Engine.h has been included, so every other object in BOUNTYDASH_API (they include BountyDash.h by default) has access to the functions within Engine.h. This is a good place to include utility functions you wish all objects to have access to. In this file, include the following lines of code:

template<typename T>
T* GetCustomGameMode(UWorld* worldContext)
{
    return Cast<T>(worldContext->GetAuthGameMode());
}

This code, simply put, is a template function that takes in a game world handle. Get the game mode from this context via the GetAuthGameMode() function, then cast this game mode to the template type provided to the function. We must cast to the template type as the GetAuthGameMode() simply returns a AGameMode handle. Now, with that in place, let's begin coding our never ending floor!

The class definition for the floor is very basic. All we need is a Tick() function and some accessor methods, so we may provide some information about the floor to other objects. I have also removed the BeginPlay function provided by default by the class wizard as it is not needed. The following is what you will need to write for the AFloor class definition in its entirety. Replace what is present in Floor.h with this now (keeping the #include list intact):

UCLASS()
class BOUNTYDASH_API AFloor : public AActor
{
GENERATED_BODY()
	
public:	
    // Sets default values for this actor's properties
    AFloor();
    
    // Called every frame
    virtual void Tick( float DeltaSeconds ) override;

    float GetKillPoint();
    float GetSpawnPoint();

protected:
    UPROPERTY(EditAnywhere)
    TArray<USceneComponent*> FloorMeshScenes;

    UPROPERTY(EditAnywhere)
    TArray<UStaticMeshComponent*> FloorMeshes;

    UPROPERTY(EditAnywhere)
    UBoxComponent* CollisionBox;

    int32 NumRepeatingMesh;
    float KillPoint;
    float SpawnPoint;
};

We have three UPROPERTY declared members. The first two being TArrays that will hold handles to the USceneComponent and UMeshComponent objects that will make up the floor. We require the TArray of scene components, as the USceneComponent objects provide us with a world transform that we can apply translations to so that we may update the position of the generated floor mesh pieces. The last UPROPERTY is a collision box that will be used for the actual player collisions to prevent the player from falling through the moving floor. The reason we are using a BoxComponent instead of the meshes for collision is that we do not want the player to translate with the moving meshes. Due to surface friction simulation, having the character collide with any of the moving meshes will cause the player to move with the mesh.

The last three members are protected and do not require any UPROPRTY specification. We are simply going to use the two float values, KillPoint and SpawnPoint, to save output calculations from the constructor so we may use them in the Tick() function. The integer value NumRepeatingMesh will be used to determine how many meshes we will have in the chain.

As always, we will start with the constructor of the floor. It is here that we will be performing the bulk of our calculations for this object. We will be creating USceneComponents and UMeshComponents that we are going to use to make up our moving floor. With dynamic programming in mind, we should establish the construction algorithm so that we can create any number of meshes in the moving line. Also as we will be getting the speed of the floors movement form the game mode, ensure that #include "BountyDashGameMode.h" is included in Floor.cpp.

RootComponent =CreateDefaultSubobject<USceneComponent>(TEXT("Root"));

ConstructorHelpers::FObjectFinder<UStaticMesh>myMesh(TEXT(
"/Game/Barrel_Hopper/Geometry/Floor_Mesh_BountyDash.Floor_Mesh_BountyDash"));

ConstructorHelpers::FObjectFinder<UMaterial>myMaterial(TEXT(
"/Game/StarterContent/Materials/M_Concrete_Tiles.M_Concrete_Tiles"));

if (myMesh.Succeeded())
{
    NumRepeatingMesh = 3;

    FBoxSphereBounds myBounds = myMesh.Object->GetBounds();
    float XBounds = myBounds.BoxExtent.X * 2;
    float ScenePos = ((XBounds * (NumRepeatingMesh - 1)) / 2.0f) * -1;

    KillPoint = ScenePos - (XBounds * 0.5f);
    SpawnPoint = (ScenePos * -1) + (XBounds * 0.5f);

for (int i = 0; i < NumRepeatingMesh; ++i)
{
// Initialize Scene
FString SceneName = "Scene" + FString::FromInt(i);
FName SceneID = FName(*SceneName);
USceneComponent* thisScene = CreateDefaultSubobject<USceneComponent>(SceneID);
check(thisScene);

thisScene->AttachTo(RootComponent);
thisScene->SetRelativeLocation(FVector(ScenePos, 0.0f, 0.0f));
ScenePos += XBounds;

floorMeshScenes.Add(thisScene);

// Initialize Mesh
FString MeshName = "Mesh" + FString::FromInt(i);
UStaticMeshComponent* thisMesh = CreateDefaultSubobject<UStaticMeshComponent>(FName(*MeshName));
check(thisMesh);

thisMesh->AttachTo(FloorMeshScenes[i]);
thisMesh->SetRelativeLocation(FVector(0.0f, 0.0f, 0.0f));
thisMesh->SetCollisionProfileName(TEXT("OverlapAllDynamic"));

if (myMaterial.Succeeded())
{
	thisMesh->SetStaticMesh(myMesh.Object);
	thisMesh->SetMaterial(0, myMaterial.Object);
}

FloorMeshes.Add(thisMesh);
} // <--Closing For(int i = 0; i < numReapeatingMesh; ++i)

collisionBox =CreateDefaultSubobject<UBoxComponent>(TEXT("CollsionBox"));check(collisionBox);

collisionBox->AttachTo(RootComponent);
collisionBox->SetBoxExtent(FVector(spawnPoint, myBounds.BoxExtent.Y, myBounds.BoxExtent.Z)); 
collisionBox->SetCollisionProfileName(TEXT("BlockAllDynamic"));

} // <-- Closing if(myMesh.Succeeded())

float AFloor::GetKillPoint()
{
    return KillPoint;
}

float AFloor::GetSpawnPoint()
{
    return SpawnPoint;
}

for (auto Scene : FloorMeshScenes)
{
Scene->AddLocalOffset(FVector(GetCustomGameMode
<ABountyDashGameMode>(GetWorld())->GetInvGameSpeed(), 0.0f, 0.0f));

if (Scene->GetComponentTransform().GetLocation().X <= KillPoint)
{
    Scene->SetRelativeLocation(FVector(SpawnPoint, 0.0f, 0.0f));
}
}

We are done making the floor! Compile the code and return to the level editor. We can now place this new floor object in the level! Delete the static mesh that would have replaced our earlier box brushes and drag and drop the Floor object into the scene. The floor object can be found under the C++ classes folder of the content browser. Select the Floor in the level and ensure that its location is set too (0.0f, 0.0f, and -100.f). This will place the floor just below the player's feet around origin. Also ensure the ATargetPoints we placed earlier are in the right positions above the lanes. With this all in place, you should be able to press play and observe the floor moving underneath the player indefinitely. You should see something similar to this:

You will notice that as you move between the lanes by pressing A and D the player maintains the X Position of the target points but nicely travels to the center of each lane.

This will be another fairly simple object. It will require a BeginPlay function, so we may find the floor and all the target points we require for spawning. We also require a Tick function so that we may process spawning logic on a per frame basis. Thankfully, both of these are provided by default by the class wizard. We created a protected SpawnObstacle() function, so we may group that functionality together. We are also going to require a few UPRORERTY declared members that can be edited from the level editor. We need a list of obstacle types to spawn; we can then randomly select one of the types each time we spawn an obstacle. We also require the spawn targets (though we will be populating these upon begin play). Finally, we will need a spawn time that we can set for the interval between obstacles spawning. To accommodate for all of this, navigate to ObstacleSpawner.h now and modify the class definition to match the following:

UCLASS()
class BOUNTYDASH_API AObstacleSpawner : public AActor
{
    GENERATED_BODY()
    
public:	
    // Sets default values for this actor's properties
    AObstacleSpawner();

    // Called when the game starts or when spawned
    virtual void BeginPlay() override;
    
    // Called every frame
    virtual void Tick( float DeltaSeconds ) override;


protected:

    void SpawnObstacle();

public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    TArray<TSubclassof<class AObstacle*>> ObstaclesToSpawn;

    UPROPERTY()
    TArray<class ATargetPoint*>SpawnTargets;

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    float SpawnTimer;
    
    UPROPERTY()
    USceneComponent* scene;
private:
    float KillPoint;
    float SpawnPoint;
   float TimeSinceLastSpawn;
};

I have again used TArrays for our containers of obstacle objects and spawn targets. As you can see the obstacle list is of type TSubclassof<class AObstacle>>. This means that the objects in this TArray will be class types that inherit from AObscatle. This is very useful as not only will we be able to use these array elements for spawn information; the engine will also filter our search when adding object types to this array from the editor! With these class types, we will be able to spawn objects that inherit from AObject (including blueprints!) when required. We also included a scene object, so we can arbitrarily place AObstacleSpawner in the level somewhere and two private members that will hold the kill and spawn point of the objects. The last element is a float timer that will be used to gauge how much time has passed since the last obstacle spawn.

Okay, now we can create the body of the AObstacleSpawner object. Before we do, ensure the include list in ObstacleSpawner.cpp is as follows:

#include "BountyDash.h"
#include "BountyDashGameMode.h"
#include "Engine/TargetPoint.h"
#include "Floor.h"
#include "Obstacle.h"
#include "ObstacleSpawner.h"

Following this, we have a very simple constructor that establishes the root scene component:

// Sets default values
AObstacleSpawner::AObstacleSpawner()
{
// 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;

Scene = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
check(Scene);
RootComponent = scene;

SpawnTimer = 1.5f;
}

Following the constructor, we have BeginPlay(). Inside this function, we are going to do a few things. First, we are simply performing the same in level object retrieval we executed in ABountyDashCarhacter to get the location of ATargetPoints. However, this object also requires information from the floor object in the level. We are also going to get the Floor object the same way we did with the ATargetPoints by utilizing TActorIterators. We will then get the required kill and spawn point information. We will also set TimeSinceLastSpawn to SpawnTimer, so we begin spawning objects instantaneously:

// Called when the game starts or when spawned
void AObstacleSpawner::BeginPlay()
{
    Super::BeginPlay();

for(TActorIterator<ATargetPoint> TargetIter(GetWorld()); TargetIter; 
    ++TargetIter)
    {
        SpawnTargets.Add(*TargetIter);
    }

for (TActorIterator<AFloor> FloorIter(GetWorld()); FloorIter;  
       ++FloorIter)
    {
        if (FloorIter->GetWorld() == GetWorld())
        {
            KillPoint = FloorIter->GetKillPoint();
            SpawnPoint = FloorIter->GetSpawnPoint();
        }
    }
    TimeSinceLastSpawn = SpawnTimer;
}

The next function we will detail is Tick(), which is responsible for the bulk of the AObstacleSpawner functionality. Within this function, we need to check if we require a new object to be spawned based on the amount of time that has passed since we last spawned an object. Add the following code to AObstacleSpawner::Tick() underneath Super::Tick() now:

TimeSinceLastSpawn += DeltaTime;

float trueSpawnTime = spawnTime / (float)GetCustomGameMode <ABountyDashGameMode>(GetWorld())->GetGameLevel();

if (TimeSinceLastSpawn > trueSpawnTime)
{
    timeSinceLastSpawn = 0.0f;
    SpawnObstacle ();
}

Here, we are accumulating the delta time in TimeSinceLastSpawn, so we may gauge how much real time has passed since the last obstacle was spawned. We then calculate the trueSpawnTime of the AObstacleSpawner. This is based on a base SpawnTime, which is divided by the current game level retrieved from the game mode via the GetCustomGamMode() template function. This means that as the game level increases and the obstacles begin to move faster, the obstacle spawner will also spawn objects at a faster rate. If the accumulated timeSinceLastSpawn is greater than the calculated trueSpawnTime we need to call SpawnObject() and reset the timeSinceLastSpawn timer to 0.0f.

Now, we need to write the spawn function. This spawn function is going to have to retrieve some information from the components of the object that is being spawned. As we allowed our AObstacle class to be extended into blueprint, we also exposed the object to a level of versatility we must compensate for in the codebase. With the ability to customize the mesh and bounds of the Sphere Collider that makes up any given obstacle, we must be sure we spawn the obstacle in the right place regardless of size!

To do this, we are going to need to obtain information form the components contained within the spawned AObstacle class. This can be done via GetComponentByClass(). It will take the UClass* of the component you wish to retrieve and will return a handle to the component if it has been found. We can then cast this handle to the appropriate type and retrieve the information we require! Let's begin detailing the spawn function by adding the following code to ObstacleSpawner.cpp:

void AObstacleSpawner::SpawnObstacle()
{
if (SpawnTargets.Num() > 0 && ObstaclesToSpawn.Num() > 0)
{
    short Spawner = FMath::Rand() % SpawnTargets.Num();
    short Obstical = FMath::Rand() % ObstaclesToSpawn.Num();
    float CapsuleOffset = 0.0f;

Here, we ensure that both of the arrays have been populated with at least one valid member. We then generate the random look up integers that we will use to access the SpawnTargets and obstacleToSpawn arrays. This means that every time we spawn an object, both the lane spawned in and the type of the object will be randomized. We do this by generating a random value with FMath::Rand() and then we find the remainder of that number divided by the number of elements in the corresponding array. The result will be a random number that exists between 0 and the number of objects in either array minus one, which is perfect for our needs. Continue by adding the following code:

FActorSpawnParameters SpawnInfo;

FTransform myTrans = SpawnTargets[Spawner]->GetTransform();
myTrans.SetLocation(FVector(SpawnPoint, myTrans.GetLocation().Y, myTrans.GetLocation().Z));

Here, we are using a struct called FActorSpawnParameters. The default values of this struct are fine for our purposes. We will soon be parsing this struct to a function in our world context. After that, we create a transform that we will be providing to world context as well. The transform of the spawner will suffice apart from the X Component of the location. We need to adjust this so the X value of the spawn transform matches the spawn point we retrieved from the floor. We do this by setting the X component of the spawn transforms location to be the spawnPoint value we received earlier, and the other components of the location vector to be the Y and Z components of the current location.

The next thing we must do is actually spawn the object! We are going to utilize a template function called SpawnActor() that can be called form the UWorld* handle returned by GetWorld(). This function will spawn an object of a specified type in the game world at a specified location. The type of the object is determined by passing a UClass* handle that holds the object type we wish to spawn. The transform and spawn parameters of the object are also determined by the corresponding input parameters of SpawnActor(). The template type of the function will dictate the type of object that is spawned and the handle that is returned from the function. In our case, we require AObstacle to be spawned. Add the following code to the SpawnObstacle function:

AObstacle* newObs = GetWorld()-> SpawnActor<AObstacle>(obstacleToSpawn[Obstical, myTrans, SpawnInfo);

if(newObs)
{
newObs->SetKillPoint(KillPoint);

As you can see, we are using SpawnActor() with a template type of AObstacle. We use the random look up integer we generated before to retrieve the class type from the obstacleToSpawn array. We also provide the transform and spawn parameters we created earlier to SpawnActor(). If the new AObstacle was created successfully, we then save the return of this function into an AObstacle handle that we will use to set the kill point of the obstacle via SetKillPoint().

We must now adjust the height of this object. The object will more than likely spawn in the ground in its current state. We need to obtain access to the sphere component of the obstacle so that we may get the radius of this capsule and adjust the position of the obstacle, so it sits above the ground. We can use the capsule as a reliable resource as it is the root component of the obstacle, thus we can move the obstacle entirely out of the ground if we assume the base of the sphere will line up with the base of the mesh. Add the following code to the SpawnObstacle() function:

USphereComponent* obsSphere = Cast<USphereComponent>
(newObs->GetComponentByClass(USphereComponent::StaticClass()));

if (obsSphere)
{
newObs->AddActorLocalOffset(FVector(0.0f, 0.0f, obsSphere-> GetUnscaledSphereRadius()));
}
}//<-- Closing if(newObs)
}//<-- Closing if(SpawnTargets.Num() > 0 && obstacleToSpawn.Num() > 0)

Here, we are getting the sphere component out of the newObs handle we obtained from SpawnActor() via GetComponentByClass(), which was earlier mentioned. We pass the class type of a USphereComponent via the static function StaticClass() to the function. This will return a valid handle if the newObs contains USphereComponent (which we know it does). We then cast the result of this function to USphereComponent* and save it in the obsSphere handle. We ensure this handle is valid; if it is, we can then offset the actor we just spawned on the z-axis by the unscaled radius of the sphere component. This will result in all obstacles spawned be in line with the top of the floor!

Once the class generation is complete, navigate to the Coin.h file. You will notice that we are given no default functionality and we must specify it all. Still much like the AObstacle, our class definition is going to be very minimal. Most of the functionality we require for the coin has already been included in the AObstacle base class. All we need to do here is override the Tick() and MyOnActorOverlap() functions, so we can add additional coin functionality.

The following is the class definition for the ACoin object:

UCLASS()
class BOUNTYDASH_API ACoin : public AObstacle
{
    GENERATED_BODY()

    ACoin();

    // Called every frame
    virtual void Tick(float DeltaSeconds) override;

    UFUNCTION()
    virtual void MyOnActorOverlap(AActor* otherActor) override;
};

Simple right? As you can see, we declared a ACoin()constructor and we are overriding the virtual Tick function. You will notice that we have also included the UFUNCITON macro above the MyOnActorOverlap function that we will be passing to the overlap delegate for this actor so that the delegate association succeeds.

Let's now define how the coin is going to work navigate to coin.cpp now. Start by adding the following to the include list if they are not already present:

#include "BountyDash.h"
#include "BountyDashCharacter.h"
#include "BountyDashGameMode.h"
#include "Coin.h"

Now, we are going to define our coin's constructor. AObstacle base class already constructs the mesh and collider objects, so we do not have to do that here. It also provides the MyOnActorBeginOverlap function to the OnActorBeginOverlap delegate. Because the MyOnActorBeginOverlap function was specified as virtual and we have overridden this function in ACoin, we do not need to re-bind the functions. We can define our constructor with no functionality as the following:

ACoin::ACoin()
{
    
}

Following that, we can define the Tick() function. This function is going to be used to rotate the mesh component of the object so it spins while moving toward the player. Add the following to Tick()within Coin.cpp:

void ACoin::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
    Mesh->AddLocalRotation(FRotator(5.0f, 0.0f, 0.0f));
}

Here, you can see we are calling Super::Tick(), so the functionality we implemented in AObstacle is executed. We then add a local rotation to the mesh component every frame via the AddLocalRotation function. We yaw the coin roughly at 5 degrees per frame.

Ok, now we can define our overridden MyOnActorOverlap functionality. We will be detailing the collisions between objects in more detail later in the chapter. For now, we will write code that will handle when a coin is spawned on top of an obstacle object. This may happen from time to time as they will be sharing spawning locations but not necessarily have exclusive spawn times. We need to detect if the coin is currently colliding with an obstacle. If so, we need to adjust the height of the coin object, we can do that with the following code:

void ACoin::MyOnActorOverlap(AActor* otherActor)
{
    if (otherActor->GetClass()->IsChildOf(AObstacle::StaticClass()))
    {
USphereComponent* thisSphere = Cast<USphereComponent>(GetComponentByClass(USphereComponent::StaticClass()));

USphereComponent* otherSpehre = Cast<USphereComponent>(otherActor-> GetComponentByClass(USphereComponent::StaticClass()));

        if (otherSpehre)
        {
AddActorLocalOffset(FVector(0.0f, 0.0f, (otherSpehre-> GetUnscaledSphereRadius() * 2.0f) + Collider-> GetUnscaledSphereRadius()));
        }
    }
} 

The first thing we do is use the class type information of the AActor object to see if the offending actor is either a AObstacle or a child of AObstacle. We do this with the IsChildOf()function. This function can be called on any actor to determine if it is a child of a specific class type or of that type itself. For the input parameter, we parse the class type of AObstacle via StaticClass(). If this check succeeds, we need to get information from the sphere component of the other actor now proven to be of type AObstacle. We do this as we did previously using GetComponentByClass() and parsing the class information of the type of component we require. We then check that this function returned a valid handle. If so, we will add a local offset to the coin actor. We will only be adding an offset on the z-axis. We will offset by the otherSphere radius * 2 plus the radius of the coin sphere so that the coin will be placed on top of the obstacle mesh.

Let's create the blueprint that is going to extend from the coin object. Create a new Blueprint class somewhere in the content browser and inherit the blueprint from the Coin class we just made. Call this class CoinBP. We are going to assemble this blueprint in the same way we did RockObstacleBP. For the collider component, set the Sphere Radius property of the Shape section in the details panel to 60.0f. Then, set the Static Mesh property of the Static Mesh section of the mesh component to SM_AssetPlatform. After that, add a member to the Override Materials list in the Rendering section of Details panel. Set this member to be the M_Metal_Gold material. Then, change the transform settings of this component so they match the following:

You will then be presented with a blueprint object that looks like this!

We will be keeping most of the default functionality provided by the class wizard. The only function we will be removing is the Tick() method, as we are going to utilize the FTimerManager object to drive our spawning functionality. More on this later. Ensure that you remove the Tick function declaration and add the following publically declared member variables:

public:
    UPROPERTY(EditAnywhere)
    TSubclassOf<ACoin> CoinObject;

    UPROPERTY()
    TArray<class ATargetPoint*> SpawnTransforms;

    UPROPERTY()
    USceneComponent* Root;

    UPROPERTY(EditAnywhere)
    int32 MaxSetCoins;

    UPROPERTY(EditAnywhere)
    int32 MinSetCoins;

    UPROPERTY(EditAnywhere)
    float CoinSetTimeInterval;

    UPROPERTY(EditAnywhere)
    float CoinTimeInterval;

    UPROPERTY(EditAnywhere)
    float MovementTimeInterval;

Here, we have a TSubclassOf<class ACoin> handle called CoinObject. This has been declared as EditAnywhere, as we wish to edit this value from the editor much like the obstacle TArray of AObstacleSpawner. It will act as the class object that we use when spawning the coins. We included another TArray of ATargetpoints to be used for our coin spawn locations. Following that is another USceneComponent that will be used to arbitrarily position the spawner in the world. Underneath that, we have all of the properties that we are going to use to dictate the spawning logic for the coins. You will notice that they have all been declared with the UPROPERTY macro and specified, so we may edit the values from the editor. MaxSetCoins and MinSetCoins will be used to determine a random number of coins to spawn within a set between those two maxims. Next, we have all of the float timers that will dictate how long it takes between each major spawner action. We have one for each set of coins, each individual coin within a set, and a movement interval.

Following that, we have our protected members that will be used for internal logic and thus do not need to be exposed:

protected:
    void SpawnCoin();
    void SpawnCoinSet();
    void MoveSpawner();

    int32 NumCoinsToSpawn;

    float KillPoint;
    float SpawnPoint;
    int32 TargetLoc;

    FTimerHandle CoinSetTimerHandle;
    FTimerHandle CoinTimerHandle;
    FTimerHandle SpawnMoveTimerHandle;

We declared several spawning functions. These functions are going to be used to invoke the various spawning methods we require for our coins. We then declare a series of variables. The first NumCoinsToSpawn is an integer value that will hold the number of coins we need to spawn for any given set. We also have the two float values KillPoint and SpawnPoint that will be used for spawning logics. Following this, we have an int value that will be used to determine within which lane we are spawning coins.

Lastly, we have a new object type we have yet to interact with the FTimerHandle object. Unlike our obstacle spawner, we are not going to be using traditional float timers that are incremented within a Tick() function. We are instead going to be leveraging the TimerManager object that is present in our GameWorld (UWorld). Through the time manager, we are able to create timer objects that will invoke a provided function after a given time period. The three timer handles here will be used to initialize the various timers we require for this coin spawner.

With our member variables set up, we can now define how the coin spawner will function. As always, ensure the include list at the top of the coinspawner.cpp matches these:

#include "BountyDash.h"
#include "Engine/TargetPoint.h"
#include "Coin.h"
#include "Floor.h"
#include "CoinSpawner.h"

The constructor for the coin spawner is very simple and does not require much of an explanation. The constructor simply initializes USceneComponent and assigns it as the root and establishes some default values for the coin spawn variables. Ensure that the ACoinSpawner constructor found in the CoinSpawner.cpp matches the following:

// Sets default values
ACoinSpawner::ACoinSpawner()
{
// 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;

    Root = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
    RootComponent = Root;

MaxSetCoins = 5;
    MinSetCoins = 3;
    CoinSetTimeInterval = 4.0f;
    CoinTimeInterval = 0.5f;
    MovementTimeInterval = 1.0f;
}

We then need to define our BeginPlay() function. This function will be responsible for obtaining the information we require from our level as well as initialize the timers we spoke of earlier. Add the following definition for ACoinSpawner::BeginPlay() now:

// Called when the game starts or when spawned
void ACoinSpawner::BeginPlay()
{
    Super::BeginPlay();

for (TActorIterator<ATargetPoint> TargetIter(GetWorld());
     TargetIter; ++TargetIter)
    {
        SpawnTransforms.Add(*TargetIter);
    }

    for (TActorIterator<AFloor> FloorIter(GetWorld()); FloorIter; 
            ++FloorIter)
    {
        if (FloorIter->GetWorld() == GetWorld())
        {
            KillPoint = FloorIter->GetKillPoint();
            SpawnPoint = FloorIter->GetSpawnPoint();
        }
    }

    // Create Timers
    FTimerManager& worldTimeManager = GetWorld()->
      GetTimerManager();

worldTimeManager.SetTimer(CoinSetTimerHandle, this, &ACoinSpawner::SpawnCoinSet, CoinSetTimeInterval, false);

worldTimeManager.SetTimer(SpawnMoveTimerHandle, this, &ACoinSpawner::MoveSpawner, MovementTimeInterval, true);
}

As you can see, the first section of BeginPlay() is identical to that of the AObstacleSpawner. Following this, however, we are creating two of the timers we are using for the spawning logic. We first get a handle to the timer manager for this game world via GetWorld()->GetTimeManager(). With this FTimeManager handle, we are able to set two of the timers we require. We do this via SetTimer(). This method takes in an FTimerHandle to populate (we provide the handles we declared in the ACoinSpawner class definition), an object to call the provided function on, a handle to the function we wish executed upon timer completion, a timer rate (how long it will take for the timer to execute), and if we wish the timer to loop.

Here, we are setting two timers. The first is a coin set timer; this timer will invoke our SpawnCoinSet function after a provided time (4.0f by default). We specified that this method is to not loop as we will be resetting this timer ourselves. The second timer we are setting is the Move timer; this timer will invoke MoveSpawner() every second by default. This method will periodically shift the lane in which the coins spawn.

Next, we must define the various methods that will be invoked by our timers. Let's begin with the SpawnCoinSet function. Add the following code to CoinSpawner.cpp now:

void ACoinSpawner::SpawnCoinSet()
{
    NumCoinsToSpawn = FMath::RandRange(MinSetCoins, MaxSetCoins);
    
    FTimerManager& worldTimeManager = GetWorld()->
GetTimerManager();

    // Swap active timers
worldTimeManager.ClearTimer(CoinSetTimerHandle);

worldTimeManager.SetTimer(CoinTimerHandle, this, &ACoinSpawner::SpawnCoin, CoinTimeInterval, true);
}

The first thing we do is generate the number of coins we will be spawning in this set by calling FMath::RandRange and providing the two maxims we declared earlier. As the SpawnCoinSet() method was invoked via a timer we now need to clear the coin set timer and active the per coin timer. This is so we can guarantee our spawn coin set timer will only reactivate once all individual coins for a given set have been spawned. We can do this by calling ClearTimer() on the FTimerManager handle, which will remove the timer from execution. We parse the handle of the timer we wish to clear to the manager (in this case CoinSetTimerHandle).

Following this, we set another timer via the SetTimer method we used earlier. This time we are setting the individual spawn coin timer. We have set this timer to loop as we wish the timer continue to spawn coins until all coins have been spawned. Following this, we can define the MoveSpawner function. This function is very simple and simply changes the TargetLoc integer we declared earlier. This integer will be used for a look up into the SpawnTransforms array. Add the following function definition to the CoinSpawner.cpp:

void ACoinSpawner::MoveSpawner()
{
    TargetLoc = FMath::Rand() % SpawnTransforms.Num();
}
We are nearly done with the coin spawner. The last thing we need to do is define the SpawnCoin() function. This function is very similar to AObstacleSpawn::SpawnObstacle(). It appears as follows:
void ACoinSpawner::SpawnCoin()
{
    FActorSpawnParameters spawnParams;

    FTransform coinTransform = SpawnTransforms[TargetLoc]->
GetTransform();

coinTransform.SetLocation(FVector(SpawnPoint, coinTransform.GetLocation().Y, coinTransform.GetLocation().Z));

ACoin* spawnedCoin = GetWorld()->SpawnActor<ACoin>(CoinObject, coinTransform, spawnParams);

    if (spawnedCoin)
    {
USphereComponent* coinSphere = Cast<USphereComponent>(spawnedCoin->
GetComponentByClass(USphereComponent::StaticClass()));

        if (coinSphere)
        {
        float offset = coinSphere->
GetUnscaledSphereRadius();

spawnedCoin->AddActorLocalOffset(FVector(0.0f, 0.0f, offset));
        }

        NumCoinsToSpawn--;
    }

    if (NumCoinsToSpawn <= 0)
    {
        FTimerManager& worldTimeManager = GetWorld()->
GetTimerManager();
    
worldTimeManager.SetTimer(CoinSetTimerHandle, this, &ACoinSpawner::SpawnCoinSet, CoinSetTimeInterval, false);

        worldTimeManager.ClearTimer(CoinTimerHandle);
    }
}

The first section of this function is exactly the same as the spawn method used in the AObstacleSpawner. The most noticeable difference is the inclusion of the timer swap logic and the end of the function. Each time a coin has spawned, we decremented the NumCoinsToSpawn variable. Once this value has reached 0 or lower, we swap our timers again. This swap is very similar to the one we performed in the SpawnCoinSet() method, yet this time we are clearing the individual coin timer and resetting the coin set timer.