pkMinhas

This post is a repost of my blog entry.
The following article & the code is intended for developers using the Unity engine for their game.

Homing missiles have been my favorite in all types of games. There is nothing more fun than a fire & forget weapon. Homing missiles will generally lock on to a target & keep following it till a collision occurs OR the missile might auto-destruct after a certain period of time.

I have implemented homing missiles in Hawks using a kinematic rigidbody in order to keep things simple. A kinematic rigidbody’s transform can be manipulated directly. Hence, it is much easier to write code for such an object.
The following script should be attached to a gameobject having a Rigidbody component with isKinematic set to true.

A basic homing missile will operate based on three properties: Speed, Auto Destruct time & target.

1. Speed: Since we are using a kinematic rigidbody, the speed of the projectile can be controlled by translating in the Update() function:

   transform.Translate(0,0,speed * Time.deltaTime,Space.Self);

2. Auto Destruct: This functionality can be implemented by calling a coroutine which self-destructs after a set amount of time:

   function Start () {
   	StartCoroutine(AutoExplode());
   }
   
   private function ExplodeSelf() {
   	Instantiate(explosion,transform.position,Quaternion.identity);
   	Destroy(gameObject);
   }
   
   private function AutoExplode() {
   	yield WaitForSeconds(autoDestroyAfter);
   	ExplodeSelf();
   }

3. Target: The missile needs to follow the target. We can achieve this by rotating the missile towards the target transform using the wonderful Slerp function:

   var relativePos : Vector3 = target.position - transform.position;
   var rotation : Quaternion = Quaternion.LookRotation(relativePos);
   transform.rotation = Quaternion.Slerp(transform.rotation, rotation, homingSensitivity);

Notice the homingSensitivity variable that is used as the last parameter to the Quaternion.Slerp(from, to, t) function. To understand its usage, we need to look at what the Slerp actually does. Slerp == Spherical Interpolation. Mathematical details available at: En.wikipedia.org. For those not so mathematically inclined, given two values, the Slerp function will calculate an intermediate position between ‘from’ & ‘to’ based on the third parameter which lies in the range [0,1]. If the third param is 0, the ‘from’ value will be returned & 1 will return the ‘to’ value. Try experimenting with different values to achieve the desired effect in your game.

Below is the complete code for the HomingMissile.js script:

#pragma strict
var target : Transform;
var speed : float;

var autoDestroyAfter : float;
//prefab for explosion
var explosion : GameObject;

/* Represents the homing sensitivity of the missile. 
Range [0.0,1.0] where 0 will disable homing and 1 will make it follow the target like crazy.
This param is fed into the Slerp (defines the interpolation point to pick) */
var homingSensitivity : float = 0.1;

function Start () {
	StartCoroutine(AutoExplode());
}

function Update () {
	if(target != null) {
		var relativePos : Vector3 = target.position - transform.position;
		var rotation : Quaternion = Quaternion.LookRotation(relativePos);

		transform.rotation = Quaternion.Slerp(transform.rotation, rotation, homingSensitivity);
	}

	transform.Translate(0,0,speed * Time.deltaTime,Space.Self);
}

function OnTriggerEnter(other: Collider) {
	//Damage the other gameobject & then destroy self
        ExplodeSelf();
}

private function ExplodeSelf() {
	Instantiate(explosion,transform.position,Quaternion.identity);
	Destroy(gameObject);
}

private function AutoExplode() {
	yield WaitForSeconds(autoDestroyAfter);
	ExplodeSelf();
}

Like our facebook page if you find this stuff interesting:
Facebook.com