UNITY • ENGINE ARCHITECTURE

UNITY GAMEOBJECT AND COMPONENT ARCHITECTURE EXPLAINED

Understand the composition-over-inheritance design pattern that powers Unity, how to create modular reusable components, and how to avoid monolithic script design.

⏱️ 6 Min Read 🎮 Unity 2021 LTS • 2022 LTS • Unity 6 ⚡ Architecture & C# 🛡️ Best Practices

1. The GameObject as an Entity Container

Unlike traditional object-oriented programming (OOP) where entities inherit from large, deep class hierarchies (e.g., Entity > Actor > Pawn > Vehicle > FighterJet), Unity utilizes an Entity-Component model based on composition.

A GameObject is merely an empty container that defines identity, scene tree parenting, and spatial placement via its mandatory Transform component. You define what the object is by attaching components.

2. Composition in Action: Building a Combat Fighter Jet

Consider the fighter jets in Operation Black Sky. Instead of writing a single 3,000-line FighterJet.cs script, the aircraft is assembled from small, focused, single-responsibility components:

Jet Flight Rig
Transform (Position/Rotation)
Rigidbody (Mass, Aerodynamic Drag)
MeshCollider (Convex Fuselage Bounds)
Modular Gameplay Components
HealthSystem.cs (Damage, Armor, Death)
FlightController.cs (Pitch, Roll, Thrust)
WeaponLauncher.cs (Missile Pods, Ammo)
Sensory & Audio Components
EngineAudioModulator.cs (Dynamic Pitch)
RadarLockTarget.cs (Missile Homing Lock)
CockpitHudVisualizer.cs (Speed & Alt)

If you want to create an enemy drone or a naval gunboat, you simply reuse HealthSystem.cs and WeaponLauncher.cs without rewriting core logic!

3. Creating a Modular Custom Component in C#

Here is a modular HealthSystem.cs component that can be attached to any player, enemy, destructible building, or vehicle: 

using System;
using UnityEngine;

/// <summary>
/// Generic, modular health system that fires C# events when damaged or killed.
/// </summary>
public class HealthSystem : MonoBehaviour
{
    [Header("Health Config")]
    [SerializeField] private float maxHealth = 100f;
    [SerializeField] private float currentHealth;

    // Events allow other scripts to react without hard references
    public event Action<float, float> OnHealthChanged; // current, max
    public event Action OnDeath;

    public bool IsDead => currentHealth <= 0f;

    private void Awake()
    {
        currentHealth = maxHealth;
    }

    public void TakeDamage(float amount)
    {
        if (IsDead) return;

        currentHealth = Mathf.Max(0f, currentHealth - amount);
        OnHealthChanged?.Invoke(currentHealth, maxHealth);

        if (IsDead)
        {
            OnDeath?.Invoke();
        }
    }

    public void Heal(float amount)
    {
        if (IsDead) return;

        currentHealth = Mathf.Min(maxHealth, currentHealth + amount);
        OnHealthChanged?.Invoke(currentHealth, maxHealth);
    }
}

4. Accessing Components Efficiently

When one component needs to interact with another on the same GameObject, use TryGetComponent inside Awake() or during collision events: 

private void OnTriggerEnter(Collider other)
{
    // TryGetComponent avoids allocating garbage if the component does not exist!
    if (other.TryGetComponent<HealthSystem>(out HealthSystem targetHealth))
    {
        targetHealth.TakeDamage(25f);
        Destroy(gameObject); // Destroy bullet
    }
}

Related Architecture Guides

Component Guides

Common Troubleshooting

Frequently Asked Questions

Yes, for most components like BoxCollider, AudioSource, and custom C# scripts unless the script is tagged with [DisallowMultipleComponent]. However, a GameObject can only ever have ONE Transform and ONE Rigidbody component.
In standard GetComponent<T>(), if the component is missing, Unity's internal native wrapper allocates a small amount of garbage in the Editor profile to track the null check. TryGetComponent<T>(out var comp) completely avoids this allocation, resulting in faster and cleaner execution.