Intended Audience

This tutorial is meant for people who are familiar to C#/C++ and who need a cool neat trick in their arsenal. This can be used for long ranged boss abilities or just a way to make the player feel empowered when they dodge the “bullet tracking” attack.

Games That Use Tracking Bullets

Let’s quickly look at a few games that do this that were successful in doing this. In Dark Souls 3, Alrdich, The Devour of Gods, uses blue magic casts that follow the player after a moment. In Kingdom Hearts 2, the king phases had tracking lasers that followed the player.

What I Call Handler and Projectile Relationship

This may be a programming paradigm, or it may not be but I have found what I believe to be a decent way of handling any spawned object which I call Handler and Projectile Relationship. The idea is you have a Handler for the spawned objects. Let’s start by creating the Handler. The handler is responsible for spawning objects from a specific location and a specific amount of objects and that is its only purpose.

Handler Setup

public class BulletTrackingHandler: MonoBehaviour
  //object to be spawned multiple times
  [SerializeField] private GameObject m_FireCastProjectile;
  //number of projectiles to be spawned
  [SerializeField] private int m_NumberOfBullets = 10;

  void Update()
    //testing handler function with a keycode press
    if (Input.GetKeyDown(KeyCode.H) == true)
      //calling the spawning function

 //function to spaw the projectiles
 void CastRangeBurst(int NumberOfBullets)
    //spawn projectiles from location
    for (int i = 0; i < NumberOfBullets; ++i)
      //spawn the projectile object
      //this object will contain the projectile script 
      //which handles the heavy lifting of the bullet
      GameObject firebullet_spawn = 
      Instantiate(m_FireCastProjectile, this.transform.position,  Quaternion.identity);

Projectile Setup

This is the class that hard carries everything. Recently I have been into Finite State Machines for this system. A Finite State Machine is simple to understand and we will be utilizing its capabilities. We are going to use the update loop for the projectile as a state machine. The idea is we are going to have the bullet go through phases which are states in this case. One for linearly interpolating to set positions, another for waiting in place, and lastly going towards the player.

public class BulletTrackingProjectile : MonoBehaviour
  //this vector is used for lerping objects to random directions within a unit circle scaled
  [SerializeField] private Vector3 m_Vec3Scale = new Vector3(4.0f, 1.0f, 4.0f);
  //speed of the bullet
  [SerializeField] private float m_BulletSpeedInDirectionOfPlayer = 2.0f;
  //timer for waiting when the projectiles reach its target position
  [SerializeField] private float m_Timer = 1.0f;
  //destroy projectile after it spawns
  [SerializeField] private float m_DestroyAfterTime = 7.5f;
  //this is the special sauce for projectiles to feel good
  [SerializeField] private float m_StopTrackingDistance = 5.0f;
  //this is a scaled unit circle
  private Vector3 random_within_circle_radius;
  //current position of projectile
  private Vector3 currentPos;
  //rigidbody for the projectile
  private Rigidbody m_Rigid;
  //lerp timer
  private float TimeTillTarget = 0.0f;
  //state checking for bullet interpolation
  private bool m_BulletLerpEnded = false;
  //state checking for the timer
  private bool m_TimerDone = false;

  // Start is called before the first frame update
  void Start()
    //this is setting up the scaled unit sphere, this is the point in which the projectiles will go through
    random_within_circle_radius = 
    RandomScaledVector3(Random.insideUnitSphere, m_Vec3Scale);
    //current position of the projectile
    currentPos = this.transform.position;
    //setting up the rigidbody component for the projectile
    m_Rigid = GetComponent<Rigidbody>();
  //Vector3 component-wise scaling 
  Vector3 RandomScaledVector3(Vector3 A, Vector3 B)
    return new Vector3(A.x * B.x, A.y * B.y, A.z * B.z);

  // Update is called once per frame
  void Update()
    //bullet state 
    TimeTillTarget += Time.deltaTime;

    if (TimeTillTarget < 1.0f)
      //lerp the bullet to the positions within the random circle
      transform.position = 
      Vector3.Lerp(currentPos, currentPos + random_within_circle_radius, TimeTillTarget);
      //lerp state has finished
      m_BulletLerpEnded = true;

    //timer state
    if (m_Timer > 0.0f)
      //setting the velocity to 0 to be safe but also so the bullet doesnt fly off after the timer is up
      m_Rigid.velocity =;
      //tick down the timer
      m_Timer -= Time.deltaTime;
      //set the timer state as it is done now
      m_TimerDone = true;

    //add bullet speed state
    if (m_BulletLerpEnded == true && m_TimerDone == true)
      //track the players movements 
      //(the addition of the vector here is for aiming at the center of the player)
      Vector3 direction = Player.BaseInstanceObject.transform.position + 
      new Vector3(0.0f, .6f, 0.0f) - this.transform.position;

      //if the distance between the bullet and player is less than m_StopTrackingDistance
      //direction of the bullet is now its velocity
      if (Vector3.Distance(gameObject.transform.position, 
         Player.BaseInstanceObject.transform.position) < m_StopTrackingDistance)
        //set direction the bullet was facing in (special sauce for making it feel good)
        direction = gameObject.GetComponent<Rigidbody>().velocity;

      //set the velocity of the bullet
      Vector3 accel = (direction).normalized * m_BulletSpeedInDirectionOfPlayer;
      m_Rigid.velocity = accel;

      //destroy after X secodns after some amount of time
      Destroy(this.gameObject, m_DestroyAfterTime);

The Special Sauce, Let’s Talk Design

At first when I was writing this piece of code, I had it where the bullets always tracked the player. It was almost impossible for the player to dodge the projectiles. So I thought, how could I make it where it feels threatening without cheating the player? And that is when I figured it out. We want to make the player feel threatened enough until the very last moment. They key here is making them “feel” something at the end of the attack.

Let’s look through the states of dodging this specific attack. The first state is running away either directly left or right. This will be a neutral action for the player. It will be satisfying to dodge the attack this way but there is no risk and no reward. You are exactly in the state as were before the attack. It will not feel empowering. The second state is running away from the attack which is the worst action the player can take. You may or may not dodge the attack this way. The third way is to run through towards the cast. This comes with high risk and high reward however this is one of the most empowering feelings the player could ever feel. And this is what we want.

Programming the Special Sauce

How do we quantify design in lines of code. For each line we write, it may hold paragraph and paragraphs of design work. Putting it into cohesive words that be can be transcribed into code is what makes design hard. In this case, after a lot of trial and error, I conceived 4 magical lines of code that really gave the feeling to this attack.

  if (Vector3.Distance(gameObject.transform.position, Player.BaseInstanceObject.transform.position) < m_StopTrackingDistance)
        //set direction the bullet was facing in (special sauce for making it feel good)
        direction = gameObject.GetComponent<Rigidbody>().velocity;

That’s it. A small distance check was what I needed to change the feeling of the whole attack. Allowing designers to change the m_StopTrackingDistance gave the attack a whole new dynamic and was exactly what we needed.

Improvements That Can Be Made

  • Bullets pathing via Bezier Curve towards the player
  • Rotating bullets in the direction they are going
  • Having an option for bullets to go one at a time instead of all at the same time

These are a few improvements that I would personally like to add for future use. Thank you for reading this tutorial on Tracking Bullets and how to make them feel good! If you have any questions or improvements, email m at!