Monsters in very basic games don't usually have complex motion behaviors. Usually they just walk towards the target and attack it. We'll program that type of monster in this game, but mind you, you can get more interesting play with monsters that position themselves advantageously on the terrain to perform ranged attacks and so on. We're not going to program that here, but it's something to think about.

In order to get the Monster character to move towards the player, we need to dynamically update the direction of the Monster character moving in each frame. To update the direction that the monster is facing, we write code in the Monster::Tick() method.

The Tick function runs in every frame of the game. The signature of the Tick function is:

virtual void Tick(float DeltaSeconds) override;

You need to add this function's prototype to your AMonster class in your Monster.h file. If we override Tick, we can place our own custom behavior that the Monster character should do in each frame. Here's some basic code that will move the monster toward the player during each frame:

void AMonster::Tick(float DeltaSeconds)
{
  Super::Tick( DeltaSeconds );

  // basic intel: move the monster towards the player
  AAvatar *avatar = Cast<AAvatar>(  UGameplayStatics::GetPlayerPawn(GetWorld(), 0) );
  if( !avatar ) return;

  FVector toPlayer = avatar->GetActorLocation() -  GetActorLocation();
  toPlayer.Normalize();	// reduce to unit vector

  // Actually move the monster towards the player a bit
  AddMovementInput(toPlayer, Speed*DeltaSeconds);

  // At least face the target
  // Gets you the rotator to turn something
  // that looks in the `toPlayer` direction
  FRotator toPlayerRotation = toPlayer.Rotation();
  toPlayerRotation.Pitch = 0; // 0 off the pitch
  RootComponent->SetWorldRotation( toPlayerRotation );
}

For AddMovementInput to work, you must have a controller selected under the AIController Class panel in your blueprint, as shown in the following screenshot:

If you have selected None, calls to AddMovementInput won't have any effect. To prevent this, select either the AIController class or the PlayerController class as your AIController Class.

The preceding code is very simple. It comprises the most basic form of enemy intelligence: simply move toward the player by an incrementally small amount in each frame.

Our not-so-intelligent army of monsters chasing the player

The result in a series of frames will be that the monster tracks and follows the player around the level. To understand how this works, you must remember that the Tick function is called on average about 60 times per second. What this means is that in each frame, the monster moves a tiny bit closer to the player. Since the monster moves in very small steps, his action looks smooth and continuous (while in reality, he is making small jumps and leaps in each frame).

Discrete nature of tracking: a monster's motion over three superimposed frames

Computer games are discrete in nature. In the preceding screenshot of superimposed sequences of frames, the player is seen as moving straight up the screen, in tiny steps. The motion of the monster is also in small steps. In each frame, the monster takes one small discrete step towards the player. The monster is following an apparently curved path as he moves directly toward where the player is in each frame.

To move the monster toward the player, we first have to get the player's position. Since the player is accessible in a global function, UGameplayStatics::GetPlayerPawn, we simply retrieve our pointer to the player using this function. Next we find the vector pointing from the Monster (GetActorLocation()) function that points to the player (avatar->GetActorLocation()). We need to find the vector that points from the monster to the avatar. To do this, you have to subtract the location of the monster from the location of the avatar, as shown in the following screenshot:

It's a simple math rule to remember but often easy to get wrong. To get the right vector, always subtract the source (the starting point) vector from the target (the terminal point) vector. In our system, we have to subtract the Monster vector from the Avatar vector. This works because subtracting the Monster vector from the system moves the Monster vector to the origin and the Avatar vector will be to the lower left-hand side of the Monster vector:

Subtracting the Monster vector from the system moves the Monster vector to (0,0)

Be sure to try out your code. At this point, the monsters will be running toward your player and crowding around him. With the preceding code that is outlined, they won't attack; they'll just follow him around, as shown in the following screenshot:

Right now, the monsters are not paying attention to the SightSphere component. That is, wherever the player is in the world, the monsters will move toward him in the current setup. We want to change that now.

To do so, all we have to do is have Monster respect the SightSphere restriction. If the player is inside the monster's SightSphere object, the monster will give chase. Otherwise, the monsters will be oblivious to the player's location and not chase the player.

Checking to see if an object is inside a sphere is simple. In the following screenshot, the point p is inside the sphere if the distance d between p and the centroid c is less than the sphere radius, r:

P is inside the sphere when d is less than r

So, in our code, the preceding screenshot translates to the following code:

void AMonster::Tick(float DeltaSeconds)
{
  Super::Tick( DeltaSeconds );
  AAvatar *avatar = Cast<AAvatar>(  UGameplayStatics::GetPlayerPawn(GetWorld(), 0) );
  if( !avatar ) return;
    FVector toPlayer = avatar->GetActorLocation() -  GetActorLocation();
  float distanceToPlayer = toPlayer.Size();
  // If the player is not in the SightSphere of the monster,
  // go back
  if( distanceToPlayer > SightSphere->GetScaledSphereRadius() )
  {
    // If the player is out of sight,
    // then the enemy cannot chase
    return;
  }

  toPlayer /= distanceToPlayer;  // normalizes the vector
  // Actually move the monster towards the player a bit
  AddMovementInput(toPlayer, Speed*DeltaSeconds);
  // (rest of function same as before (rotation))
}

The preceding code adds additional intelligence to the Monster character. The Monster character can now stop chasing the player if the player is outside the monster's SightSphere object. This is how the result will look:

A good thing to do here will be to wrap up the distance comparison into a simple inline function. We can provide these two inline member functions in the Monster header as follows:

inline bool isInSightRange( float d )
{ return d < SightSphere->GetScaledSphereRadius(); }
inline bool isInAttackRange( float d )
{ return d < AttackRangeSphere->GetScaledSphereRadius(); }

These functions return the value true when the passed parameter, d, is inside the spheres in question.