programming-architecture

Entity Component System (ECS)

Traditional OOP (BAD):

// Everything coupled, hard to optimize
public class Enemy : MonoBehaviour
{
    public float health;
    public float speed;
    public Rigidbody rb;

    void Update()
    {
        // Movement
        rb.velocity = transform.forward * speed;

        // AI
        if (PlayerInRange()) Attack();

        // Health
        if (health <= 0) Die();
    }
}
// Problem: 1000 enemies = 1000 Update() calls, cache misses

ECS (GOOD):

// Components are pure data
public struct Position : IComponentData
{
    public float3 Value;
}

public struct Velocity : IComponentData
{
    public float3 Value;
}

public struct Health : IComponentData
{
    public float Current;
    public float Max;
}

// Systems process components in bulk (cache-friendly)
public partial class MovementSystem : SystemBase
{
    protected override void OnUpdate()
    {
        float deltaTime = Time.DeltaTime;

        // Processes ALL entities with Position + Velocity
        // in tight loop, vectorized by Burst compiler
        Entities.ForEach((ref Position pos, in Velocity vel) =>
        {
            pos.Value += vel.Value * deltaTime;
        }).ScheduleParallel();
    }
}

public partial class HealthSystem : SystemBase
{
    protected override void OnUpdate()
    {
        var ecb = new EntityCommandBuffer(Allocator.TempJob);

        Entities.ForEach((Entity entity, in Health health) =>
        {
            if (health.Current <= 0)
            {
                ecb.DestroyEntity(entity);
            }
        }).Schedule();

        ecb.Playback(EntityManager);
        ecb.Dispose();
    }
}

Performance comparison:

// OOP: 1000 enemies
// Update() calls: 1000/frame
// Cache misses: high (scattered objects)
// Parallelization: hard

// ECS: 1000 enemies
// System calls: 1/frame per system
// Cache misses: low (contiguous arrays)
// Parallelization: automatic with Burst
// Result: 10-100x faster for large entity counts