If the only movement behavior you wish to implement for an object is a simple seek behavior, Unity does provide a very straightforward method for this purpose. The use of rigid bodies and forces is needed for the later recipes in this chapter, which is why this simple method approach was not taken for this recipe. However, you could replace the code in this recipe for the SeekTarget class with the following, which uses the MoveTowards() Unity method for a simple seek behavior:

// file: MoveTowards.cs
using UnityEngine;
using System.Collections;

public class MoveTowards : MonoBehaviour {
  public Transform playerTransform;
  public float speed = 5.0F;

  private void Update () {
    transform.LookAt(playerTransform);
    float distance = speed * Time.deltaTime;
    Vector3 source = transform.position;
    Vector3 target = playerTransform.position;
    transform.position = Vector3.MoveTowards(source, target, distance);
  }
}

The MoveTowards() method takes three arguments, namely: the source position, the target position, and how far to move towards the target.

A nicer version of the seek behavior involves the seeking object to slow down as it gets closer to the target object. This can be achieved by replacing the Seek() method with a new Arrive() method. First, replace the statement in FixedUpdate(), so that the value of adjustVelocity is returned from the Arrive() method:

Vector3 adjustVelocity = Arrive(source, target);

Next, define a constant DECELERATION_FACTOR that we need:

const float DECELERATION_FACTOR = 0.6f;

Finally, implement the Arrive() method with the following code:

private Vector3 Arrive(Vector3 source, Vector3 target){float distanceToTarget = Vector3.Distance(source, target);
  Vector3 directionToTarget = Vector3.Normalize( target - source );
  float speed = distanceToTarget / DECELERATION_FACTOR;
  Vector3 velocityToTarget = speed * directionToTarget;
  
  return velocityToTarget - rigidbody.velocity;
}

The speed (magnitude) of the force to be applied to the Arrow object will vary depending on the remaining distance to the target (player's cube). This rate of deceleration can be tweaked by changing the value of the DECELERATION_FACTOR constant. As the distance to the target is reduced (that is, as the Arrow object gets closer), the size of the force to be applied to Arrow is smaller, so it slows down as it gets closer to the target. This results in a more natural (and satisfying) movement in target-seeking game objects.

The next screenshot shows the following two debug rays of the forces on the Arrow object at a point in time:

The opposite to arrive at is the flee behavior. This involves moving in the opposite direction to where the target is. First, change FixedUpdate() so that the value of adjustVelocity is set differently according to the distance from target (its default is 0; if within the value of FLEE_RADIUS, it will be a force to move away from the target, if outside the value of SEEK_RADIUS, it will be a force to move towards the target):

Vector3 adjustVelocity = Vector3.zero;

float distanceToTarget = Vector3.Distance(target, source);
if( distanceToTarget < FLEE_RADIUS )
  adjustVelocity += Flee(source, target);

if( distanceToTarget > SEEK_RADIUS )
  adjustVelocity += Arrive(source, target);

Next, define some constants we need:

const float DECELERATION_FACTOR = 0.6f;
public const float FLEE_RADIUS = 14f;
public const float SEEK_RADIUS = 6f;

As the value of FLEE_RADIUS is larger than that of SEEK_RADIUS, when the distance to the target is between 6 and 14, then both a flee and an arrive force will be calculated, resulting in a deceleration in this overlap zone. The result is a realistic following behavior, whereby the Arrow follows at approximately 10 units, accelerating and decelerating smoothly based on the player's cube movements.

Add the Arrive() method listed in the previous section, and also add a new method called Flee() as follows:

private Vector3 Flee(Vector3 source, Vector3 target){
  float distanceToTarget = Vector3.Distance(target, source);
  Vector3 directionAwayFromTarget = Vector3.Normalize(source - target);
  float speed = (FLEE_RADIUS - distanceToTarget) / DECELERATION_FACTOR;
  Vector3 velocityAwayFromTarget = speed * directionAwayFromTarget;
  return velocityAwayFromTarget;
}

The Flee() method works in the opposite way to Arrive(), so the speed (magnitude) of the velocity force vector will be larger when the target is closer. Therefore, the Arrow will move quickly away from a nearby target.

A follow-at-a-distance behavior can be achieved by making an object flee a nearby target, but seek to arrive at a far away target.