Performance optimisation : null check in Update() - unity3d

Question

I'm currently working on a basic AI for enemies in my space shooter project.
In my EnemyAI script, I've a public Transform target that I set when I instantiate a enemy. In the Update loop, I'm looking at the target, then moving using transform.towards and everything works fine. The problem is, the target can die, so I need to check if it is not null before doing all that. Problem is : apparently doing a simple if(target == null) is really bad performance wise, and I need to do it in Update. What should be the best approach to achieve that without having performance problems (let say I want 500 enemies at once). Should I still do it every X frame, cache the position of the target till the next check and move toward that cached result ? That could work but it would introduce jitter if the time between two check if too long.
I couldn't find any "easy" way but I hope there is one, it looks like something really simple and it's causing a lot of troubles :/

Answer 1

Null checks are not that expensive.
Coroutines can help spread the load over multiple frames. But carefully read about their memory usage / garbage collection problems.
You could speed that up using the ECS system (Entity Component System) in combination with C# Jobs (multithreaded)
Use the Profiler (Window -> Profiler) or (Window -> Analysis -> Profiler in 2018.3) to analyse what's actually taking long.
A for-each is bad (garbage-collection wise) compared to a normal for.
If you set position and rotation, group the two calls by using SetPositionAndRotation

Answer 2

Note null check with UnityEngine.Object children are NOT the standard C# null checks. This description that Jetbrains provides in relation to the Rider IDE and analysis tool gets into the details. The basic idea is that the C# script hands off the null check to the underlying C++ engine structure.
I have not had the need for it but I have seen other's code that keeps a simple list of UnityEngine.Object references. They add a reference to the object to the list when it is created. Then remove it from the list on destruction. Update() can then use a faster test in the list. Where speed is critical, you just test the list not the object. Of course, an approach other than a list could be used.

Answer 3

I looked it up and tested it and yes you can do this with a callback function which will be registered to your target's OnDestroy method. Your Player script should access target script and delegate the method like this:
public GameObject target;
private TargetScript myTargetScript;
void Start () {
myTargetScript = target.GetComponent<TargetScript>();
myTargetScript.OnDestroyEvnt += OnDestroyListener;
}
private void OnDestroyListener(MonoBehaviour instance)
{
Debug.Log("Callback is called");
}
Also Target script should be like this:
public event OnDestroyDelegate OnDestroyEvnt;
public delegate void OnDestroyDelegate(MonoBehaviour instance);
void Start () {
StartCoroutine(DestroyCoroutine());
}
private void OnDestroy()
{
if (this.OnDestroyEvnt != null)
{
this.OnDestroyEvnt(this);
}
}
IEnumerator DestroyCoroutine()
{
yield return new WaitForSeconds(5);
Destroy(gameObject);
}
I used a coroutine to destroy the object after 5 secs. It is actually irrelevant in your case. I adopted this code from here.

Answer 4

You can avoid it logic-wise, make a coroutine that only runs when you assign the target, and if the target is null, end the coroutine, that coroutine should have a...
yield return new WaitForEndOfFrame();
that way it will act as a kind of LateUpdate.
And check every frame...
while (target != null)
You would be still checking every frame the null, but you will only check the target = null once.