Best Practice for Validating Components in Unity/C#?

Question

In my game there's a Unit class, which all soldiers use. Not all soldiers have special abilities which require unique class components (like Stealth class). Special abilities either exist on a unit from the start, or never.

Special classes like Stealth are monobehaviour classes which provide specific functionality, and the fact a unit is or is not Stealth will need referenced by other classes. For example, the classes which handle unit shooting and detection must check whether a unit in proximity is stealth. I'm wondering what is the best way to handle this case with Unity, given components?

Right now the Unit class' Start function checks if the special class exists, and assigns a private boolean to true. This boolean can only get accessed by a get function. Does this make sense for more easily readable and secure code? Or is it overengineering?

private bool isStealth;

if (GetComponent<Stealth>())
{
    isStealth = true;
}

public bool IsStealth()
{
    return isStealth;
}

Answer 1

Your solution is fine. Although “secure coding” is not what you’re doing so much as “decoupled coding” which is a laudable goal.

An even more decoupled alternative is to have the solution be more generic, so that the Unit class need not know about the Stealth class at all, for example by using an enum. It can then be extended if the Unit has other properties set up via Components without needing to modify the Unit class (more than trivially) for each property.

For example (warning: untested):

[Flags]
public enum UnitProperty {
    Stealth = 1,
    Boss = 2,
    Slow = 4,
    MadeOfJelly = 8,
    //etc.
}

public interface UnitPropertySource {
    UnitProperty GetProperty();
}

public class Stealth : MonoBehaviour, UnitPropertySource {
    public UnitProperty GetProperty() {
        return UnitProperty.Stealth;
    }
    //other stealthy stuff
}


public class Unit : MonoBehaviour {
    private UnitProperty properties;
    private void Start() {
        foreach (var propertySource in GetComponents<UnitPropertySource>()) {
           properties |= propertySource.GetProperty();
        }
    }
    public bool HasProperty(UnitProperty p) {
        return properties & p == p;
    }
    public bool IsStealth {
        get {
            return HasProperty(UnitProperty.Stealth);
        }
    }
    public bool IsMadeOfJelly {
        get {
            return HasProperty(UnitProperty.MadeOfJelly);
        }
    }
}

Answer 2

Your approach seems fine as long as a Stealth component cannot be added during runtime. Otherwise you should get rid of the bool field and just write your IsStealth method like so:

public bool IsStealth()
{
    return GetComponent<Stealth>();
}

Because a bool is returned, GetComponent<Stealth>() will be casted automatically.

Unity also provides a special method for validating values in MonoBehaviour called OnValidate. This is useful if you have public fields (or in Unity docs sometimes called properties) that require validation. But in your case it makes more sense to validate during runtime, because the isStealth field should not be public if its value depends on some other component.