Best practice for giving properties to game objects

Question

I'm not a noob in Unity although not the most experienced one, but during one of my project a noob question came to my mind! Strange but this never was an issue for me during my old projects... I became confused where should I initialize the basic properties of my agents.

Example: I have some workers (agents) in a strategy game and they can extract resources. For this I can create a script which executes the process; also I need a variable which define the maximum amount of collected resource the agent can carry. Normally I would create this property in the "Extracting" script which is fine, but should I really create different scripts for (almost) every property of an agent?

There's some properties which are very general like "HP" for example... the HP can be used in many scripts and has no proper script to define/initialize it, but there's ton of other examples...

My idea to organize this thing to create a 'Property' script where I would write all of the properties which need for the given agent type. But in this case I have to connect the script to other ones which would use any property of this agent (by GetComponent<>)

Under the hood a GameObject is a class right? There's any way to add some variable (for properties) to the specified GameObject and access these variables from any scripts of which is attached to that GameObject?

What is the proper way to do this?

Answer 1

For HP, I'd recommend creating a Health component, something like this...

public class Health : MonoBehaviour {

    public float maxHP = 100;

    public UnityEvent OnDeath;

    float _currentHP;

    void Start() {
        _currentHP = maxHP;
    }

    public void TakeDamage(float damage) {
        if (_currentHP <= 0f) return;

        _currentHP -= damage;
        if (_currentHP > 0f) return;

        _currentHP = 0f;
        if (OnDeath != null) OnDeath.Invoke();

        Destroy(gameObject);
    }
}

Now you can add a Health component to anything that needs to be able to take damage: characters, breakable objects, etc.

Any script that needs to interact with the Health component on itself or on a target it's damaging / healing can do so with GetComponent<Health>()

Now you don't need to re-invent the wheel for each one - you can share one common implementation of HP-tracking and death-invoking across everything that needs it, and make new damageable or invulnerable entities and variants as simply as adding or removing a Health component from them.

You can follow this pattern for each identifiable function your agents need. Some agents extract resources? Put the properties they need in a ResourceExtractor component. Some agents can attack? Put the properties they need in an Attack component. etc.

This is an approach called Composition Over Inheritance - instead of stacking all possible behaviours we might need on the parent GameObject, we import just the ones we care about for a given entity by attaching the right combination of components to it.

---

For properties that are the same for a large number of objects (like max HP or max carrying capacity, not current HP/current load which can vary for each instance), you can use the flyweight pattern or type object pattern to store them in a common object, something like...

[CreateAssetMenu(fileName = "newAgentProperties.asset", menuName = "Properties/Agent Properties")]
public class AgentProperties : ScriptableObject {

    public float movementSpeed;
    public float carryingCapacity;
    // ... etc.  
}

Then your agent script can simply store a reference to these shared properties:

public class Agent : MonoBehaviour {

    public AgentProperties properties;

    // ... Add per-instance properties and actions here.
}

Answer 2

You could declare a public string, which will be the identifier, and make the specific workers have different roles, depending on the string’s value. For example, something like this:

public string Job;

void MineStone() 
{
   if (Job == miner) 
   {
       // mine function goes here
   }
}

Answer 3

No, you can't extend GameObject to add more variables to it (The Unreal Engine works like that, by the way, but Unity doesn't). Properties of a gameObject belong to the component (aka MonoBehaviour) where they make the most sense thematically and technically.

So a property like HP belongs into the Component which handles reacting to damage and destroying the object. You can then add that component to any object which is supposed to be destructible. When a script now needs to know if the object it is on is damaged, then it would do so by accessing the Health component via GetComponent.

When you develop a MonoBehavior which only works when a different component is also on the same gameObject, then you can declare that through the RequireComponent attribute. That way the Unity editor will automatically add required components for you and warn you when they go missing.