ARCHITECTURE_HANDBOOK

Architecture Handbook

System-Based Design for Tower Defense Game

Version: 2.0 Last Updated: December 2025 Architecture Pattern: System-Based (ECS-inspired) Target Framework: Unity 2022.3 LTS

---

📚 Table of Contents

1. Introduction

2. Core Architectural Concepts

3. Design Patterns

4. Interface System

5. System Implementations

6. Entity Design

7. Performance Principles

8. Best Practices

9. Migration Guide

10. Appendix

---

1. Introduction

1.1 Purpose of This Document

This Architecture Handbook serves as the authoritative reference for the tower defense game's system-based architecture. It documents:

• Design philosophy and architectural decisions

• Implementation patterns for core systems

• Performance optimizations that achieved +125% FPS improvement

• Best practices for maintaining and extending the codebase

Target Audience:

• Senior/Lead developers maintaining the codebase

• New team members onboarding to the project

• Technical architects reviewing the system design

1.2 Project Context

Challenge: A procedurally generated tower defense game suffering from severe performance issues (63.9 FPS) due to monolithic architecture with 11,900+ Update() calls per second.

Solution: Complete architectural refactoring implementing system-based design inspired by Entity Component System (ECS) principles, without the complexity of Unity DOTS.

Results:

• FPS: 63.9 → 144.1 (+125%)

• CPU Time: 15.6ms → 6.9ms (-56%)

• Update() calls: 11,900/sec → 50/sec (-99.5%)

• Maintainability: Significantly improved

• Testability: 0% → 75% coverage

1.3 Architectural Philosophy

Core Principles

1. Separation of Concerns

• Entities = Data providers (implement interfaces)

• Systems = Logic processors (batch operations)

• Managers = High-level orchestration

2. Interface-Driven Design

• All capabilities defined by interfaces (IMoveable, IAttacker, etc.)

• Systems work with interfaces, not concrete classes

• Easy to mock for testing

3. Batch Processing Over Individual Updates

• Replace N Update() calls with 1 Tick() call per system

• Cache-friendly sequential iteration

• Predictable, measurable performance

4. Priority-Based Execution

• Systems execute in defined order (0 = Movement, 1 = Attack, etc.)

• Prevents race conditions

• Clear data flow

5. Lifecycle Management

• Centralized initialization (GameSystemsManager)

• Proper cleanup (OnEnable/OnDisable pattern)

• No memory leaks

Design Goals

✅ Performance: 100+ FPS sustained under heavy load ✅ Maintainability: Clear, documented, SOLID-compliant code ✅ Extensibility: Easy to add new systems, entities, behaviors ✅ Testability: Unit tests for all systems (75% coverage) ✅ Scalability: Support 200+ entities without FPS drop

---

2. Core Architectural Concepts

2.1 System-Based Architecture Overview

The Problem: Monolithic Update() Pattern

Traditional Unity MonoBehaviour pattern:

┌──────────────────────────────────────────────────────────┐
│  MONOLITHIC ARCHITECTURE (Anti-Pattern)                  │
├──────────────────────────────────────────────────────────┤
│                                                          │
│  Every entity has Update() method                       │
│  ↓                                                       │
│  Unity calls Update() on EVERY MonoBehaviour            │
│  ↓                                                       │
│  50 Enemies × Update() = 3,000 calls/second             │
│  10 Towers × Update() = 600 calls/second                │
│  30 Effects × Update() = 1,800 calls/second             │
│  20 Projectiles × Update() = 1,200 calls/second         │
│  ↓                                                       │
│  TOTAL: 11,900+ Update() calls per second               │
│                                                          │
│  PROBLEMS:                                               │
│  ❌ High CPU overhead (virtual method dispatch)         │
│  ❌ Poor cache locality (scattered memory access)       │
│  ❌ Difficult to optimize (logic spread everywhere)     │
│  ❌ Hard to test (tight coupling)                       │
│  ❌ No control over execution order                     │
│                                                          │
└──────────────────────────────────────────────────────────┘

The Solution: System-Based Architecture

Our implementation:

┌──────────────────────────────────────────────────────────┐
│  SYSTEM-BASED ARCHITECTURE (Optimized)                   │
├──────────────────────────────────────────────────────────┤
│                                                          │
│  GameSystemsManager                                      │
│    └─ Update() ← Unity's ONLY Update() call             │
│         ↓                                                │
│         foreach (system in systems)                      │
│           ├─ MovementSystem.Tick()    [Priority: 0]     │
│           │    └─ foreach (entity in moveables)         │
│           │         └─ entity.UpdatePosition()          │
│           │                                              │
│           ├─ AttackSystem.Tick()      [Priority: 1]     │
│           │    └─ foreach (tower in attackers)          │
│           │         └─ tower.SelectTarget()             │
│           │         └─ tower.PerformAttack()            │
│           │                                              │
│           ├─ ProjectileSystem.Tick()  [Priority: 2]     │
│           │    └─ foreach (proj in projectiles)         │
│           │         └─ proj.UpdatePosition()            │
│           │         └─ proj.CheckCollision()            │
│           │                                              │
│           └─ EffectSystem.Tick()      [Priority: 3]     │
│                └─ foreach (effect in effects)           │
│                     └─ effect.ProcessTick()             │
│                     └─ effect.UpdateDuration()          │
│                                                          │
│  TOTAL: 4 system Tick() calls = ~50 calls/second        │
│                                                          │
│  BENEFITS:                                               │
│  ✅ Low CPU overhead (sequential batch processing)      │
│  ✅ Excellent cache locality (contiguous iteration)     │
│  ✅ Easy to optimize (centralized logic)                │
│  ✅ Easy to test (system isolation)                     │
│  ✅ Controlled execution order (priority-based)         │
│                                                          │
└──────────────────────────────────────────────────────────┘

Key Differences

Aspect	MonoBehaviour Pattern	System-Based Pattern
Update Calls	N entities × 60 FPS = 3,600/sec	1 system × 60 FPS = 60/sec
Performance	❌ Poor (high overhead)	✅ Excellent (batch processing)
Testability	❌ Difficult (tight coupling)	✅ Easy (interface-based)
Profiling	❌ Hard (scattered logic)	✅ Easy (centralized methods)
Execution Order	❌ Undefined	✅ Explicit (priority-based)
Memory Access	❌ Random (cache misses)	✅ Sequential (cache-friendly)

2.2 The Three Pillars

Pillar 1: Entities (Data Providers)

Definition: GameObjects that hold data and implement capability interfaces.

Responsibilities:

• Store state (health, position, speed, etc.)

• Implement interfaces (IMoveable, IAttacker, IDamageable)

• Provide data to systems

• Register/unregister with systems in OnEnable/OnDisable

Example:

public class Enemy : MonoBehaviour, IMoveable, IDamageable, ITargetable
{
    // STATE (data)
    private float currentHealth = 100f;
    private float moveSpeed = 5f;
    private Vector3 direction;
    
    // LIFECYCLE (registration)
    private void OnEnable()
    {
        MovementSystem.Instance?.RegisterMoveable(this);
    }
    
    private void OnDisable()
    {
        MovementSystem.Instance?.UnregisterMoveable(this);
    }
    
    // INTERFACES (capabilities)
    
    // IMoveable implementation
    public Transform Transform => transform;
    public float Speed => moveSpeed;
    public Vector3 Direction 
    { 
        get => direction;
        set => direction = value;
    }
    public bool IsMoving { get; set; } = true;
    
    public void UpdatePosition(float deltaTime)
    {
        transform.position += direction * Speed * deltaTime;
    }
    
    // IDamageable implementation
    public float MaxHealth => 100f;
    public float CurrentHealth => currentHealth;
    
    public void TakeDamage(float amount)
    {
        currentHealth -= amount;
        if (currentHealth <= 0)
            Die();
    }
    
    public void Heal(float amount)
    {
        currentHealth = Mathf.Min(currentHealth + amount, MaxHealth);
    }
    
    // ITargetable implementation
    public Vector3 Position => transform.position;
    public bool IsAlive => currentHealth > 0;
    public int WaypointIndex { get; set; }
    
    private void Die()
    {
        // Death logic
        PoolManager.Instance.Push(gameObject);
    }
}

Key Points:

• ✅ NO Update() method (logic handled by systems)

• ✅ Implements multiple interfaces (composition over inheritance)

• ✅ Registers with systems in OnEnable (works with object pooling)

• ✅ Clean separation: data vs logic

Pillar 2: Systems (Logic Processors)

Definition: MonoBehaviour singletons that process batches of entities.

Responsibilities:

• Implement IGameSystem interface

• Register/unregister entities dynamically

• Process ALL entities in single Tick() call

• Maintain entity lists/dictionaries for fast lookup

Example:

public class MovementSystem : MonoBehaviour, IGameSystem
{
    // SINGLETON PATTERN (managed by GameSystemsManager)
    public static MovementSystem Instance { get; private set; }
    
    // SYSTEM PROPERTIES
    public int Priority => 0; // Execute first
    public bool IsActive { get; set; } = true;
    
    // ENTITY REGISTRY
    private List<IMoveable> moveables = new List<IMoveable>();
    
    // LIFECYCLE
    private void Awake()
    {
        if (Instance != null)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
    }
    
    public void Initialize()
    {
        Debug.Log("[MovementSystem] Initialized");
    }
    
    public void Shutdown()
    {
        moveables.Clear();
        Debug.Log("[MovementSystem] Shutdown");
    }
    
    // BATCH PROCESSING (called by GameSystemsManager)
    public void Tick(float deltaTime)
    {
        // SINGLE PASS for ALL moving entities
        for (int i = 0; i < moveables.Count; i++)
        {
            IMoveable moveable = moveables[i];
            
            if (!moveable.IsMoving)
                continue;
            
            // Update position (entity-specific logic)
            moveable.UpdatePosition(deltaTime);
        }
    }
    
    // ENTITY MANAGEMENT
    public void RegisterMoveable(IMoveable moveable)
    {
        if (!moveables.Contains(moveable))
        {
            moveables.Add(moveable);
            Debug.Log($"[MovementSystem] Registered: {moveable.Transform.name}");
        }
    }
    
    public void UnregisterMoveable(IMoveable moveable)
    {
        moveables.Remove(moveable);
        Debug.Log($"[MovementSystem] Unregistered: {moveable.Transform.name}");
    }
}

Key Points:

• ✅ Singleton managed by GameSystemsManager

• ✅ Batch processes ALL entities in one loop

• ✅ Priority defines execution order

• ✅ Clean registration/unregistration API

Pillar 3: Manager (Orchestrator)

Definition: Master controller that initializes and executes systems.

Responsibilities:

• Initialize all systems on scene load

• Execute systems in priority order

• Provide system lookup API

• Handle system lifecycle

Example:

public class GameSystemsManager : MonoBehaviour
{
    // SINGLETON
    public static GameSystemsManager Instance { get; private set; }
    
    // SYSTEM REFERENCES (assigned in Inspector or created at runtime)
    [Header("Systems")]
    [SerializeField] private MovementSystem movementSystem;
    [SerializeField] private AttackSystem attackSystem;
    [SerializeField] private ProjectileSystem projectileSystem;
    [SerializeField] private EffectSystem effectSystem;
    
    // SYSTEM REGISTRY (sorted by Priority)
    private List<IGameSystem> systems = new List<IGameSystem>();
    
    // LIFECYCLE
    private void Awake()
    {
        if (Instance != null)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
        DontDestroyOnLoad(gameObject);
        
        InitializeSystems();
    }
    
    private void InitializeSystems()
    {
        Debug.Log("[GameSystemsManager] Initializing systems...");
        
        // Create systems if not assigned
        if (movementSystem == null)
        {
            GameObject systemObj = new GameObject("MovementSystem");
            systemObj.transform.SetParent(transform);
            movementSystem = systemObj.AddComponent<MovementSystem>();
        }
        
        if (attackSystem == null)
        {
            GameObject systemObj = new GameObject("AttackSystem");
            systemObj.transform.SetParent(transform);
            attackSystem = systemObj.AddComponent<AttackSystem>();
        }
        
        if (projectileSystem == null)
        {
            GameObject systemObj = new GameObject("ProjectileSystem");
            systemObj.transform.SetParent(transform);
            projectileSystem = systemObj.AddComponent<ProjectileSystem>();
        }
        
        if (effectSystem == null)
        {
            GameObject systemObj = new GameObject("EffectSystem");
            systemObj.transform.SetParent(transform);
            effectSystem = systemObj.AddComponent<EffectSystem>();
        }
        
        // Register systems (automatically sorted by Priority)
        RegisterSystem(movementSystem);
        RegisterSystem(attackSystem);
        RegisterSystem(projectileSystem);
        RegisterSystem(effectSystem);
        
        // Initialize all systems
        foreach (var system in systems)
        {
            system.Initialize();
        }
        
        Debug.Log($"[GameSystemsManager] Initialized {systems.Count} systems");
    }
    
    // MAIN UPDATE LOOP (Unity's only Update() call!)
    private void Update()
    {
        float deltaTime = Time.deltaTime;
        
        // Execute systems in priority order
        foreach (var system in systems)
        {
            if (system.IsActive)
            {
                system.Tick(deltaTime);
            }
        }
    }
    
    // SYSTEM REGISTRATION
    private void RegisterSystem(IGameSystem system)
    {
        if (system == null)
            return;
        
        systems.Add(system);
        
        // Sort by priority (lower = execute first)
        systems.Sort((a, b) => a.Priority.CompareTo(b.Priority));
    }
    
    // PUBLIC API
    public T GetSystem<T>() where T : IGameSystem
    {
        foreach (var system in systems)
        {
            if (system is T typedSystem)
                return typedSystem;
        }
        return default(T);
    }
    
    // CLEANUP
    private void OnDestroy()
    {
        foreach (var system in systems)
        {
            system.Shutdown();
        }
        systems.Clear();
    }
}

Key Points:

• ✅ Single Update() call for entire game

• ✅ Systems execute in priority order (sorted automatically)

• ✅ Manages system lifecycle (Initialize → Tick → Shutdown)

• ✅ Provides system lookup API

2.3 Data Flow

Execution Flow Diagram

Frame Start
    ↓
GameSystemsManager.Update()
    ↓
    ├─► MovementSystem.Tick() [Priority: 0]
    │     └─► foreach (IMoveable entity)
    │           └─► entity.UpdatePosition(deltaTime)
    │                ↓
    │                Entity transforms updated
    │
    ├─► AttackSystem.Tick() [Priority: 1]
    │     └─► foreach (IAttacker tower)
    │           ├─► tower cooldown updated
    │           ├─► SelectTarget() (uses updated positions!)
    │           └─► tower.PerformAttack(target)
    │                ↓
    │                Projectiles spawned
    │
    ├─► ProjectileSystem.Tick() [Priority: 2]
    │     └─► foreach (IProjectile projectile)
    │           ├─► projectile.UpdatePosition(deltaTime)
    │           ├─► projectile.CheckHit()
    │           └─► if hit → damage target
    │                ↓
    │                Damage applied to targets
    │
    └─► EffectSystem.Tick() [Priority: 3]
          └─► foreach (IEffect effect)
                ├─► effect.UpdateDuration(deltaTime)
                ├─► effect.UpdateTickTimer(deltaTime)
                └─► if tick ready → effect.PerformTick()
                     ↓
                     DOT damage applied
Frame End

Why This Order?

1. Movement First (Priority 0): All entities move to new positions. This ensures other systems see updated positions.

2. Attack Second (Priority 1): Towers select targets based on updated positions. No stale data.

3. Projectile Third (Priority 2): Projectiles move and check collision against updated positions.

4. Effects Last (Priority 3): Effects apply DOT/debuffs after all movement and combat resolved.

Critical: Priority order prevents race conditions and ensures predictable behavior.

2.4 Memory Layout

Cache-Friendly Iteration

Problem: Random memory access (cache misses)

// BAD: Each Update() call jumps to different memory location
void Update() // Called on Enemy #1 at address 0x1000
void Update() // Called on Tower #4 at address 0x5000
void Update() // Called on Enemy #2 at address 0x1100
void Update() // Called on Tower #1 at address 0x4000
// Random jumps = cache misses = slow!

Solution: Sequential iteration (cache hits)

// GOOD: System iterates contiguously stored list
List<IMoveable> moveables; // Stored sequentially in memory

public void Tick(float deltaTime)
{
    // Iterate sequentially
    for (int i = 0; i < moveables.Count; i++)
    {
        moveables[i].UpdatePosition(deltaTime);
    }
    // Sequential access = cache hits = fast!
}

Performance Impact:

Cache Miss Cost: ~100 cycles
Cache Hit Cost: ~4 cycles

100 entities with random access:
100 × 100 cycles = 10,000 cycles

100 entities with sequential access:
100 × 4 cycles = 400 cycles

Speedup: 25×

---

3. Design Patterns

3.1 System Pattern (Custom ECS-like)

Intent

Centralize logic in reusable systems that batch process entities, eliminating scattered Update() calls.

Structure

┌─────────────────────────────────────────────────┐
│            IGameSystem (Interface)              │
├─────────────────────────────────────────────────┤
│ + Priority : int                                │
│ + IsActive : bool                               │
│ + Initialize() : void                           │
│ + Tick(deltaTime : float) : void                │
│ + Shutdown() : void                             │
└─────────────────────────────────────────────────┘
                     △
                     │ implements
                     │
     ┌───────────────┴───────────────┐
     │                               │
┌─────────────────┐       ┌─────────────────┐
│ MovementSystem  │       │  AttackSystem   │
├─────────────────┤       ├─────────────────┤
│ - moveables[]   │       │ - attackers[]   │
│ + Tick()        │       │ + Tick()        │
└─────────────────┘       └─────────────────┘

Implementation

// Step 1: Define System Interface
public interface IGameSystem
{
    int Priority { get; }
    bool IsActive { get; set; }
    void Initialize();
    void Tick(float deltaTime);
    void Shutdown();
}

// Step 2: Implement Concrete System
public class MovementSystem : MonoBehaviour, IGameSystem
{
    public int Priority => 0;
    public bool IsActive { get; set; } = true;
    
    private List<IMoveable> moveables = new List<IMoveable>();
    
    public void Initialize()
    {
        Debug.Log("[MovementSystem] Ready");
    }
    
    public void Tick(float deltaTime)
    {
        for (int i = 0; i < moveables.Count; i++)
        {
            moveables[i].UpdatePosition(deltaTime);
        }
    }
    
    public void Shutdown()
    {
        moveables.Clear();
    }
    
    public void RegisterMoveable(IMoveable moveable)
    {
        moveables.Add(moveable);
    }
}

// Step 3: Orchestrate in Manager
public class GameSystemsManager : MonoBehaviour
{
    private List<IGameSystem> systems = new List<IGameSystem>();
    
    private void Update()
    {
        float deltaTime = Time.deltaTime;
        
        foreach (var system in systems)
        {
            if (system.IsActive)
                system.Tick(deltaTime);
        }
    }
}

Benefits

✅ Single Responsibility: Each system handles one concern ✅ Open/Closed Principle: Add new systems without modifying existing ✅ Easy Testing: Mock IGameSystem interface ✅ Performance: Batch processing, cache-friendly ✅ Predictable: Priority-based execution order

Applicability

Use when:

• You have many entities performing similar operations

• Performance is critical (batch processing needed)

• You want centralized, testable logic

Don't use when:

• Entities have completely unique behaviors (no batching benefit)

• Overhead of registration outweighs batching benefits (<10 entities)

3.2 Observer Pattern (Event-Driven)

Intent

Decouple systems by using events for communication instead of direct references.

Structure

┌────────────┐                    ┌────────────┐
│   Enemy    │────dies───event───►│ WaveManager│
│            │                    │            │
│ OnDied()   │                    │OnEnemyDied│
└────────────┘                    └────────────┘
     │                                  │
     └──────────────┬───────────────────┘
                    │
                    ▼
          No direct reference!

Implementation

// Step 1: Define Event
public class Enemy : MonoBehaviour
{
    // Event declaration
    public event Action<Enemy> OnDied;
    
    private void Die()
    {
        // Invoke event
        OnDied?.Invoke(this);
        
        // Cleanup
        PoolManager.Instance.Push(gameObject);
    }
}

// Step 2: Subscribe to Event
public class WaveManager : MonoBehaviour
{
    private void Start()
    {
        // Find all enemies and subscribe
        Enemy[] enemies = FindObjectsOfType<Enemy>();
        foreach (var enemy in enemies)
        {
            enemy.OnDied += HandleEnemyDied;
        }
    }
    
    private void HandleEnemyDied(Enemy enemy)
    {
        enemiesRemaining--;
        
        if (enemiesRemaining <= 0)
        {
            OnWaveCompleted?.Invoke();
        }
    }
    
    private void OnDestroy()
    {
        // CRITICAL: Unsubscribe to prevent memory leaks!
        Enemy[] enemies = FindObjectsOfType<Enemy>();
        foreach (var enemy in enemies)
        {
            enemy.OnDied -= HandleEnemyDied;
        }
    }
}

Benefits

✅ Loose Coupling: No direct references between systems ✅ Extensibility: Easy to add new listeners ✅ Testability: Can mock event handlers ✅ Clean Communication: Event names are self-documenting

Critical Notes

⚠️ Always unsubscribe in OnDestroy to prevent memory leaks!

// Memory leak example:
private void Start()
{
    enemy.OnDied += HandleDeath; // Subscribe
}

// OnDestroy() missing!
// Enemy still has reference to this object even after destruction!
// This = MEMORY LEAK!

// Correct:
private void OnDestroy()
{
    enemy.OnDied -= HandleDeath; // Unsubscribe
}

3.3 Object Pool Pattern

Intent

Reuse GameObjects instead of constantly creating/destroying to reduce GC pressure.

Structure

┌─────────────────────────────────────────────┐
│            PoolManager (Singleton)           │
├─────────────────────────────────────────────┤
│ - pools : Dictionary<GameObject, Queue>     │
│ + Pull(prefab : GameObject) : GameObject    │
│ + Push(instance : GameObject) : void        │
└─────────────────────────────────────────────┘
         │                          │
         │ Pull()                   │ Push()
         ▼                          ▼
  ┌──────────┐              ┌──────────┐
  │ Inactive │─activate────►│  Active  │
  │  Pool    │              │ In Game  │
  │   []     │◄──deactivate─│          │
  └──────────┘              └──────────┘

Implementation

public class PoolManager : MonoBehaviour
{
    public static PoolManager Instance { get; private set; }
    
    // Pools: Prefab → Queue of inactive instances
    private Dictionary<GameObject, Queue<GameObject>> pools =
        new Dictionary<GameObject, Queue<GameObject>>();
    
    private void Awake()
    {
        Instance = this;
    }
    
    // Get object from pool (or create if pool empty)
    public GameObject Pull(GameObject prefab)
    {
        // Create pool if doesn't exist
        if (!pools.ContainsKey(prefab))
        {
            pools[prefab] = new Queue<GameObject>();
        }
        
        GameObject instance;
        
        if (pools[prefab].Count > 0)
        {
            // Reuse from pool
            instance = pools[prefab].Dequeue();
            instance.SetActive(true);
        }
        else
        {
            // Create new instance
            instance = Instantiate(prefab);
        }
        
        return instance;
    }
    
    // Return object to pool
    public void Push(GameObject instance)
    {
        instance.SetActive(false);
        
        // Find pool for this instance
        GameObject prefab = GetPrefabFor(instance);
        if (prefab != null)
        {
            pools[prefab].Enqueue(instance);
        }
    }
    
    // Create pool with pre-spawned objects
    public void CreatePool(GameObject prefab, int count)
    {
        pools[prefab] = new Queue<GameObject>();
        
        for (int i = 0; i < count; i++)
        {
            GameObject instance = Instantiate(prefab);
            instance.SetActive(false);
            pools[prefab].Enqueue(instance);
        }
    }
}

Critical: OnEnable vs Start

⚠️ Pooled objects reset in OnEnable(), NOT Start()!

// ❌ WRONG: Start() only runs ONCE per GameObject
public class Projectile : MonoBehaviour
{
    void Start()
    {
        // This ONLY runs on first spawn!
        // When pulled from pool again, this won't execute!
        rigidbody.velocity = direction * speed;
    }
}

// ✅ CORRECT: OnEnable() runs EVERY time object activated
public class Projectile : MonoBehaviour
{
    void OnEnable()
    {
        // This runs EVERY time object is pulled from pool!
        rigidbody.velocity = direction * speed;
        currentLifetime = 0f;
        
        // Register with system
        ProjectileSystem.Instance?.RegisterProjectile(this);
    }
    
    void OnDisable()
    {
        // Unregister when returned to pool
        ProjectileSystem.Instance?.UnregisterProjectile(this);
    }
}

Why OnEnable()?

First Spawn:
Instantiate() → Awake() → OnEnable() → Start()

From Pool:
SetActive(true) → OnEnable()  (Start NOT called!)

Performance Impact

Without Pooling (100 projectiles spawning/despawning per second):
- Instantiate: 100 × 0.5ms = 50ms/sec
- Destroy: 100 × 0.5ms = 50ms/sec
- GC Collect: ~100ms every 5 seconds
Total overhead: ~120ms/sec

With Pooling:
- Pull from pool: 100 × 0.01ms = 1ms/sec
- Return to pool: 100 × 0.01ms = 1ms/sec
- GC Collect: ~10ms every 50 seconds
Total overhead: ~2.2ms/sec

Improvement: 98% reduction in overhead!

3.4 Strategy Pattern (Targeting)

Intent

Define family of algorithms (targeting strategies), encapsulate each, make them interchangeable.

Structure

┌────────────────────────────────────┐
│    ITargetingStrategy (Interface)  │
├────────────────────────────────────┤
│ + SelectTarget(attacker, targets)  │
│     : ITargetable                  │
└────────────────────────────────────┘
            △
            │ implements
            │
   ┌────────┼────────┬────────────┐
   │        │        │            │
┌──────┐ ┌──────┐ ┌──────┐  ┌──────┐
│First │ │Last  │ │Closest│ │Strongest│
└──────┘ └──────┘ └──────┘  └──────┘

Implementation

// Step 1: Define Strategy Interface
public interface ITargetingStrategy
{
    ITargetable SelectTarget(IAttacker attacker, List<ITargetable> targets);
}

// Step 2: Implement Concrete Strategies
public class FirstTargetingStrategy : ITargetingStrategy
{
    public ITargetable SelectTarget(IAttacker attacker, List<ITargetable> targets)
    {
        if (targets.Count == 0)
            return null;
        
        // Find enemy with highest waypoint index (closest to goal)
        ITargetable best = targets[0];
        int maxIndex = best.WaypointIndex;
        
        for (int i = 1; i < targets.Count; i++)
        {
            if (targets[i].WaypointIndex > maxIndex)
            {
                best = targets[i];
                maxIndex = best.WaypointIndex;
            }
        }
        
        return best;
    }
}

public class ClosestTargetingStrategy : ITargetingStrategy
{
    public ITargetable SelectTarget(IAttacker attacker, List<ITargetable> targets)
    {
        if (targets.Count == 0)
            return null;
        
        // Find nearest enemy (use SqrMagnitude to avoid sqrt!)
        ITargetable best = targets[0];
        Vector3 attackerPos = attacker.Transform.position;
        float minDistSq = Vector3.SqrMagnitude(best.Position - attackerPos);
        
        for (int i = 1; i < targets.Count; i++)
        {
            float distSq = Vector3.SqrMagnitude(targets[i].Position - attackerPos);
            if (distSq < minDistSq)
            {
                best = targets[i];
                minDistSq = distSq;
            }
        }
        
        return best;
    }
}

// Step 3: Use Strategy in System
public class AttackSystem : MonoBehaviour, IGameSystem
{
    private Dictionary<TargetingMode, ITargetingStrategy> strategies =
        new Dictionary<TargetingMode, ITargetingStrategy>();
    
    public void Initialize()
    {
        // Register all strategies
        strategies[TargetingMode.First] = new FirstTargetingStrategy();
        strategies[TargetingMode.Last] = new LastTargetingStrategy();
        strategies[TargetingMode.Closest] = new ClosestTargetingStrategy();
        strategies[TargetingMode.Furthest] = new FurthestTargetingStrategy();
        strategies[TargetingMode.Strongest] = new StrongestTargetingStrategy();
        strategies[TargetingMode.Weakest] = new WeakestTargetingStrategy();
    }
    
    public void Tick(float deltaTime)
    {
        foreach (var attacker in attackers)
        {
            // Select target using strategy
            ITargetingStrategy strategy = strategies[attacker.TargetingMode];
            ITargetable target = strategy.SelectTarget(attacker, GetTargetsFor(attacker));
            
            // ...rest of attack logic
        }
    }
}

Benefits

✅ Extensibility: Easy to add new targeting strategies ✅ Testability: Can test each strategy in isolation ✅ Performance: Manual iteration (NO LINQ) ✅ Flexibility: Tower can switch strategy at runtime

Performance Note

⚠️ NEVER use LINQ in targeting strategies!

// ❌ SLOW (10-20× slower than manual):
var target = targets
    .OrderByDescending(t => t.WaypointIndex)
    .FirstOrDefault();

// ✅ FAST (manual iteration):
ITargetable best = targets[0];
for (int i = 1; i < targets.Count; i++)
{
    if (targets[i].WaypointIndex > best.WaypointIndex)
        best = targets[i];
}

Why?

• LINQ creates iterators (memory allocations)

• LINQ uses delegates (virtual calls)

• LINQ does full sort when only max needed

Impact:

10 towers × 50 FPS × LINQ = 500 allocations/sec = GC spikes

10 towers × 50 FPS × Manual = 0 allocations = smooth performance

3.5 Singleton Pattern (Managed)

Intent

Ensure class has only one instance, provide global access point.

Structure

┌──────────────────────────────────┐
│        GameSystemsManager        │
│            (Singleton)           │
├──────────────────────────────────┤
│ - static Instance : GSM          │
│ + GetSystem<T>() : T             │
└──────────────────────────────────┘
         │ manages
         ▼
┌──────────────────────────────────┐
│        MovementSystem            │
│            (Singleton)           │
├──────────────────────────────────┤
│ - static Instance : MS           │
│ + RegisterMoveable() : void      │
└──────────────────────────────────┘

Implementation

public class MovementSystem : MonoBehaviour, IGameSystem
{
    // Singleton instance
    public static MovementSystem Instance { get; private set; }
    
    private void Awake()
    {
        // Prevent duplicates
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        
        Instance = this;
    }
    
    private void OnDestroy()
    {
        // Clear singleton reference
        if (Instance == this)
        {
            Instance = null;
        }
    }
}

Benefits

✅ Global Access: Any entity can access system ✅ Lazy Initialization: Created when first needed ✅ Single Instance: Guaranteed only one exists ✅ Managed Lifecycle: GameSystemsManager controls creation/destruction

Anti-Pattern Warning

⚠️ Don't abuse singletons!

// ❌ BAD: Static class (can't test, can't mock)
public static class GameManager
{
    public static int Gold;
    public static void AddGold(int amount) { Gold += amount; }
}

// ✅ GOOD: Interface-based singleton
public interface IGameState
{
    int Gold { get; }
    void AddGold(int amount);
}

public class GameState : MonoBehaviour, IGameState
{
    public static GameState Instance { get; private set; }
    
    private int gold;
    public int Gold => gold;
    
    public void AddGold(int amount)
    {
        gold += amount;
        OnGoldChanged?.Invoke(gold);
    }
}

// Even better: Dependency Injection
public class Tower : MonoBehaviour
{
    [SerializeField] private IGameState gameState; // Inject
    
    void OnEnemyKilled()
    {
        gameState.AddGold(10); // Testable!
    }
}

---

4. Interface System

4.1 Interface Hierarchy

┌──────────────────────────────────────────────────────┐
│               Core Interfaces                        │
├──────────────────────────────────────────────────────┤
│                                                      │
│  IGameSystem ◄─── All systems implement             │
│      │                                               │
│      ├─ IFixedGameSystem (for physics systems)      │
│      │                                               │
│  IMoveable ◄─── Movement capability                 │
│      │                                               │
│  IAttacker ◄─── Attack capability                   │
│      │                                               │
│  ITargetable ◄─── Can be targeted                   │
│      │                                               │
│  IDamageable ◄─── Can take damage                   │
│      │                                               │
│  IProjectile ◄─── Projectile behavior               │
│      │                                               │
│  IEffect ◄─── Status effect behavior                │
│      │                                               │
│  IPoolable ◄─── Object pooling support              │
│                                                      │
└──────────────────────────────────────────────────────┘

4.2 System Interfaces

IGameSystem

Purpose: Contract for all game systems.

/// <summary>
/// Base interface for all game systems.
/// Systems are centralized processors that handle specific gameplay aspects.
/// </summary>
public interface IGameSystem
{
    /// <summary>
    /// Execution priority. Lower values execute first.
    /// Example: MovementSystem=0, AttackSystem=1, ProjectileSystem=2
    /// </summary>
    int Priority { get; }
    
    /// <summary>
    /// Whether system is currently active.
    /// Inactive systems skip Tick() execution.
    /// </summary>
    bool IsActive { get; set; }
    
    /// <summary>
    /// Called once during system initialization.
    /// Setup resources, register strategies, load data.
    /// </summary>
    void Initialize();
    
    /// <summary>
    /// Main update loop called every frame by GameSystemsManager.
    /// Process all registered entities in batch.
    /// </summary>
    /// <param name="deltaTime">Time since last frame</param>
    void Tick(float deltaTime);
    
    /// <summary>
    /// Called when system is being destroyed.
    /// Cleanup resources, unregister entities, save data.
    /// </summary>
    void Shutdown();
}

Usage:

public class CustomSystem : MonoBehaviour, IGameSystem
{
    public int Priority => 10; // Execute after core systems
    public bool IsActive { get; set; } = true;
    
    public void Initialize()
    {
        // Setup
    }
    
    public void Tick(float deltaTime)
    {
        // Process entities
    }
    
    public void Shutdown()
    {
        // Cleanup
    }
}

4.3 Entity Interfaces

IMoveable

Purpose: Entities that can move (enemies, projectiles).

/// <summary>
/// Entities capable of movement.
/// Managed by MovementSystem for batch processing.
/// </summary>
public interface IMoveable
{
    /// <summary>
    /// Transform reference for position access.
    /// </summary>
    Transform Transform { get; }
    
    /// <summary>
    /// Movement speed in units per second.
    /// </summary>
    float Speed { get; }
    
    /// <summary>
    /// Current movement direction (normalized).
    /// </summary>
    Vector3 Direction { get; set; }
    
    /// <summary>
    /// Whether entity is currently moving.
    /// </summary>
    bool IsMoving { get; set; }
    
    /// <summary>
    /// Update entity position.
    /// Called by MovementSystem.Tick().
    /// </summary>
    /// <param name="deltaTime">Time since last frame</param>
    void UpdatePosition(float deltaTime);
}

IAttacker

Purpose: Entities that can attack (towers).

/// <summary>
/// Entities capable of attacking.
/// Managed by AttackSystem for centralized combat logic.
/// </summary>
public interface IAttacker
{
    Transform Transform { get; }
    GameObject GameObject { get; }
    
    // Attack Properties
    float AttackRange { get; }
    float AttackCooldown { get; }
    float CurrentCooldown { get; set; }
    bool CanAttack { get; }
    
    // Targeting
    ITargetable CurrentTarget { get; set; }
    TargetingMode TargetingMode { get; }
    
    // Combat Stats
    float Damage { get; }
    GameObject ProjectilePrefab { get; }
    Transform ShootAnchor { get; }
    
    // Actions
    void PerformAttack(ITargetable target);
    void FocusOnTarget(Vector3 targetPosition);
    void OnTargetAcquired(ITargetable target);
    void OnTargetLost();
    void OnAttackCompleted();
}

ITargetable

Purpose: Entities that can be targeted by attackers.

/// <summary>
/// Entities that can be selected as targets.
/// </summary>
public interface ITargetable
{
    Transform Transform { get; }
    GameObject GameObject { get; }
    Vector3 Position { get; }
    bool IsAlive { get; }
    
    /// <summary>
    /// Waypoint index on path (used by targeting strategies).
    /// Higher = closer to goal.
    /// </summary>
    int WaypointIndex { get; set; }
}

IDamageable

Purpose: Entities that can take damage.

/// <summary>
/// Entities that can receive damage.
/// </summary>
public interface IDamageable
{
    float MaxHealth { get; }
    float CurrentHealth { get; }
    
    void TakeDamage(float amount);
    void Heal(float amount);
}

IProjectile

Purpose: Projectile entities.

/// <summary>
/// Projectiles managed by ProjectileSystem.
/// </summary>
public interface IProjectile
{
    GameObject GameObject { get; }
    float CurrentLifetime { get; set; }
    float MaxLifetime { get; }
    
    void UpdatePosition(float deltaTime);
    bool CheckHit(out ITargetable target);
    void OnHit(ITargetable target);
}

IEffect

Purpose: Status effects (burn, slow, poison, stun).

/// <summary>
/// Status effects managed by EffectSystem.
/// </summary>
public interface IEffect
{
    GameObject TargetGameObject { get; }
    float CurrentDuration { get; set; }
    float CurrentTickTime { get; set; }
    float TickInterval { get; }
    bool IsInfinite { get; }
    
    void PerformTick();
    void ExpireEffect();
    void OnEffectStarted();
    void OnEffectEnded();
}

4.4 Utility Interfaces

IPoolable

Purpose: Support for object pooling.

/// <summary>
/// Objects that support pooling (reuse instead of destroy/instantiate).
/// </summary>
public interface IPoolable
{
    GameObject GameObject { get; }
    bool IsInPool { get; set; }
    
    /// <summary>
    /// Called when object pulled from pool.
    /// Reset state here (NOT in Start()!).
    /// </summary>
    void OnSpawnedFromPool();
    
    /// <summary>
    /// Called when object returned to pool.
    /// Cleanup here.
    /// </summary>
    void OnReturnedToPool();
}

ITargetingStrategy

Purpose: Target selection algorithms.

/// <summary>
/// Strategy for selecting targets from available options.
/// </summary>
public interface ITargetingStrategy
{
    /// <summary>
    /// Select best target based on strategy criteria.
    /// </summary>
    /// <param name="attacker">Tower selecting target</param>
    /// <param name="targets">Available targets in range</param>
    /// <returns>Best target, or null if none</returns>
    ITargetable SelectTarget(IAttacker attacker, List<ITargetable> targets);
}

4.5 Composition Example

Entity implementing multiple interfaces:

public class Enemy : MonoBehaviour, IMoveable, IDamageable, ITargetable, IPoolable
{
    // Fields
    private float currentHealth = 100f;
    private float moveSpeed = 5f;
    private Vector3 direction;
    
    // IMoveable implementation
    public Transform Transform => transform;
    public float Speed => moveSpeed;
    public Vector3 Direction { get; set; }
    public bool IsMoving { get; set; } = true;
    
    public void UpdatePosition(float deltaTime)
    {
        transform.position += Direction * Speed * deltaTime;
    }
    
    // IDamageable implementation
    public float MaxHealth => 100f;
    public float CurrentHealth => currentHealth;
    
    public void TakeDamage(float amount)
    {
        currentHealth -= amount;
        if (currentHealth <= 0)
            Die();
    }
    
    public void Heal(float amount)
    {
        currentHealth = Mathf.Min(currentHealth + amount, MaxHealth);
    }
    
    // ITargetable implementation
    public Vector3 Position => transform.position;
    public bool IsAlive => currentHealth > 0;
    public int WaypointIndex { get; set; }
    
    // IPoolable implementation
    public GameObject GameObject => gameObject;
    public bool IsInPool { get; set; }
    
    public void OnSpawnedFromPool()
    {
        currentHealth = MaxHealth;
        IsMoving = true;
    }
    
    public void OnReturnedToPool()
    {
        IsMoving = false;
    }
    
    // Lifecycle
    private void OnEnable()
    {
        MovementSystem.Instance?.RegisterMoveable(this);
    }
    
    private void OnDisable()
    {
        MovementSystem.Instance?.UnregisterMoveable(this);
    }
    
    private void Die()
    {
        PoolManager.Instance.Push(gameObject);
    }
}

Benefits of Composition:

✅ Enemy is moveable ✅ Enemy can take damage ✅ Enemy can be targeted ✅ Enemy supports pooling ✅ Single class, multiple capabilities ✅ Each system sees only relevant interface

---

5. System Implementations

5.1 MovementSystem

Purpose

Centralized batch processor for all moving entities (enemies, projectiles).

Responsibilities

• Register/unregister IMoveable entities

• Update positions for all entities in single pass

• Handle waypoint progression

• Notify entities on destination reached

Architecture

MovementSystem
├─ Priority: 0 (execute first)
├─ Entities: List<IMoveable>
└─ Tick(): foreach entity → UpdatePosition()

Full Implementation

using System.Collections.Generic;
using UnityEngine;

public class MovementSystem : MonoBehaviour, IGameSystem
{
    // Singleton
    public static MovementSystem Instance { get; private set; }
    
    // System Properties
    public int Priority => 0; // Execute first
    public bool IsActive { get; set; } = true;
    
    // Entity Registry
    private List<IMoveable> moveables = new List<IMoveable>();
    
    // Lifecycle
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
    }
    
    public void Initialize()
    {
        Debug.Log("[MovementSystem] Initialized");
    }
    
    public void Shutdown()
    {
        moveables.Clear();
        Debug.Log("[MovementSystem] Shutdown");
    }
    
    // Main Update Loop
    public void Tick(float deltaTime)
    {
        // BATCH PROCESSING - single pass for ALL entities
        for (int i = 0; i < moveables.Count; i++)
        {
            IMoveable moveable = moveables[i];
            
            // Skip inactive
            if (!moveable.IsMoving)
                continue;
            
            // Update position
            moveable.UpdatePosition(deltaTime);
        }
    }
    
    // Entity Management
    public void RegisterMoveable(IMoveable moveable)
    {
        if (moveable == null)
            return;
        
        if (!moveables.Contains(moveable))
        {
            moveables.Add(moveable);
            Debug.Log($"[MovementSystem] Registered: {moveable.Transform.name}");
        }
    }
    
    public void UnregisterMoveable(IMoveable moveable)
    {
        if (moveable == null)
            return;
        
        moveables.Remove(moveable);
        Debug.Log($"[MovementSystem] Unregistered: {moveable.Transform.name}");
    }
    
    // Debug Info
    public int GetMoveableCount() => moveables.Count;
    
    private void OnDestroy()
    {
        if (Instance == this)
        {
            Instance = null;
        }
    }
}

Performance Metrics

BEFORE (individual Update()):
50 enemies × Update() = 3,000 calls/second
CPU time: ~4ms per frame

AFTER (batch processing):
1 MovementSystem.Tick() = 60 calls/second
CPU time: ~0.3ms per frame

Improvement: 93% reduction

Usage Example

public class Enemy : MonoBehaviour, IMoveable
{
    private float moveSpeed = 5f;
    private Vector3 direction = Vector3.forward;
    
    // Interface implementation
    public Transform Transform => transform;
    public float Speed => moveSpeed;
    public Vector3 Direction { get; set; }
    public bool IsMoving { get; set; } = true;
    
    public void UpdatePosition(float deltaTime)
    {
        transform.position += Direction * Speed * deltaTime;
    }
    
    // Registration
    private void OnEnable()
    {
        MovementSystem.Instance?.RegisterMoveable(this);
    }
    
    private void OnDisable()
    {
        MovementSystem.Instance?.UnregisterMoveable(this);
    }
}

5.2 AttackSystem

Purpose

Centralized combat processor handling targeting, cooldowns, and attack execution.

Responsibilities

• Register/unregister IAttacker entities (towers)

• Manage attack cooldowns

• Target selection using strategies (First, Closest, Strongest, etc.)

• Execute attacks (spawn projectiles)

• Handle target loss/acquisition events

Architecture

AttackSystem
├─ Priority: 1 (after movement)
├─ Entities: List<IAttacker>
├─ Cached Targets: Dictionary<IAttacker, List<ITargetable>>
├─ Strategies: Dictionary<TargetingMode, ITargetingStrategy>
└─ Tick(): foreach attacker → cooldown → target → attack

Full Implementation

using System.Collections.Generic;
using UnityEngine;

public class AttackSystem : MonoBehaviour, IGameSystem
{
    // Singleton
    public static AttackSystem Instance { get; private set; }
    
    // System Properties
    public int Priority => 1; // After movement
    public bool IsActive { get; set; } = true;
    
    // Entity Registry
    private List<IAttacker> attackers = new List<IAttacker>();
    
    // Target Caching (tower → list of targets in range)
    private Dictionary<IAttacker, List<ITargetable>> cachedTargets =
        new Dictionary<IAttacker, List<ITargetable>>();
    
    // Targeting Strategies (NO LINQ!)
    private Dictionary<TargetingMode, ITargetingStrategy> strategies =
        new Dictionary<TargetingMode, ITargetingStrategy>();
    
    // Lifecycle
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
    }
    
    public void Initialize()
    {
        // Register targeting strategies
        strategies[TargetingMode.First] = new FirstTargetingStrategy();
        strategies[TargetingMode.Last] = new LastTargetingStrategy();
        strategies[TargetingMode.Closest] = new ClosestTargetingStrategy();
        strategies[TargetingMode.Furthest] = new FurthestTargetingStrategy();
        strategies[TargetingMode.Strongest] = new StrongestTargetingStrategy();
        strategies[TargetingMode.Weakest] = new WeakestTargetingStrategy();
        
        Debug.Log($"[AttackSystem] Initialized with {strategies.Count} targeting strategies");
    }
    
    public void Shutdown()
    {
        attackers.Clear();
        cachedTargets.Clear();
        Debug.Log("[AttackSystem] Shutdown");
    }
    
    // Main Update Loop
    public void Tick(float deltaTime)
    {
        // BATCH PROCESSING - single pass for ALL attackers
        foreach (var attacker in attackers)
        {
            // 1. Update cooldown
            if (attacker.CurrentCooldown > 0f)
            {
                attacker.CurrentCooldown -= deltaTime;
                continue; // Skip if on cooldown
            }
            
            // 2. Target selection
            if (attacker.CurrentTarget == null || !IsValidTarget(attacker.CurrentTarget))
            {
                // Find new target
                ITargetable newTarget = SelectTarget(attacker);
                
                if (newTarget != attacker.CurrentTarget)
                {
                    // Target changed
                    if (attacker.CurrentTarget != null)
                    {
                        attacker.OnTargetLost();
                    }
                    
                    attacker.CurrentTarget = newTarget;
                    
                    if (newTarget != null)
                    {
                        attacker.OnTargetAcquired(newTarget);
                    }
                }
            }
            
            // 3. Focus on target
            if (attacker.CurrentTarget != null)
            {
                attacker.FocusOnTarget(attacker.CurrentTarget.Position);
            }
            
            // 4. Perform attack
            if (attacker.CanAttack && attacker.CurrentTarget != null)
            {
                attacker.PerformAttack(attacker.CurrentTarget);
                attacker.CurrentCooldown = attacker.AttackCooldown;
                attacker.OnAttackCompleted();
            }
        }
    }
    
    // Target Selection (uses cached targets + strategy)
    private ITargetable SelectTarget(IAttacker attacker)
    {
        // Get cached targets for this attacker
        if (!cachedTargets.TryGetValue(attacker, out var targets))
            return null;
        
        if (targets == null || targets.Count == 0)
            return null;
        
        // Use targeting strategy (NO LINQ - manual iteration!)
        ITargetingStrategy strategy = strategies[attacker.TargetingMode];
        return strategy.SelectTarget(attacker, targets);
    }
    
    // Validate target is still valid (alive, in range)
    private bool IsValidTarget(ITargetable target)
    {
        return target != null && target.IsAlive;
    }
    
    // Entity Management
    public void RegisterAttacker(IAttacker attacker)
    {
        if (attacker == null)
            return;
        
        if (!attackers.Contains(attacker))
        {
            attackers.Add(attacker);
            cachedTargets[attacker] = new List<ITargetable>();
            Debug.Log($"[AttackSystem] Registered: {attacker.GameObject.name}");
        }
    }
    
    public void UnregisterAttacker(IAttacker attacker)
    {
        if (attacker == null)
            return;
        
        attackers.Remove(attacker);
        cachedTargets.Remove(attacker);
        Debug.Log($"[AttackSystem] Unregistered: {attacker.GameObject.name}");
    }
    
    // Update cached targets for attacker (called by tower's scan coroutine)
    public void UpdateTargetsInRange(IAttacker attacker, List<ITargetable> targets)
    {
        if (cachedTargets.ContainsKey(attacker))
        {
            cachedTargets[attacker] = targets;
        }
    }
    
    // Debug Info
    public int GetAttackerCount() => attackers.Count;
    
    private void OnDestroy()
    {
        if (Instance == this)
        {
            Instance = null;
        }
    }
}

// Targeting Mode Enum
public enum TargetingMode
{
    First,      // Closest to goal (highest waypoint index)
    Last,       // Furthest from goal (lowest waypoint index)
    Closest,    // Nearest to tower (SqrMagnitude)
    Furthest,   // Farthest from tower
    Strongest,  // Highest HP
    Weakest     // Lowest HP
}

Performance Metrics

BEFORE (individual Update/FixedUpdate):
10 towers × FixedUpdate() = 500 calls/second (Physics.OverlapSphere)
10 towers × Update() = 600 calls/second (LINQ sorting)
500 LINQ operations/second
TOTAL: 1,600 calls/second

AFTER (batch processing + coroutines):
1 AttackSystem.Tick() = 60 calls/second
50 coroutine updates/second (target scanning)
0 LINQ operations
TOTAL: 110 calls/second

Improvement: 93% reduction

Targeting Strategy Example

public class FirstTargetingStrategy : ITargetingStrategy
{
    public ITargetable SelectTarget(IAttacker attacker, List<ITargetable> targets)
    {
        if (targets.Count == 0)
            return null;
        
        // Find enemy with highest waypoint index (NO LINQ!)
        ITargetable best = targets[0];
        int maxIndex = best.WaypointIndex;
        
        for (int i = 1; i < targets.Count; i++)
        {
            if (targets[i].WaypointIndex > maxIndex)
            {
                best = targets[i];
                maxIndex = best.WaypointIndex;
            }
        }
        
        return best;
    }
}

public class ClosestTargetingStrategy : ITargetingStrategy
{
    public ITargetable SelectTarget(IAttacker attacker, List<ITargetable> targets)
    {
        if (targets.Count == 0)
            return null;
        
        // Find nearest enemy (use SqrMagnitude to avoid sqrt!)
        ITargetable best = targets[0];
        Vector3 attackerPos = attacker.Transform.position;
        float minDistSq = Vector3.SqrMagnitude(best.Position - attackerPos);
        
        for (int i = 1; i < targets.Count; i++)
        {
            float distSq = Vector3.SqrMagnitude(targets[i].Position - attackerPos);
            if (distSq < minDistSq)
            {
                best = targets[i];
                minDistSq = distSq;
            }
        }
        
        return best;
    }
}

Usage Example

public class Tower : MonoBehaviour, IAttacker
{
    [SerializeField] private float attackRange = 5f;
    [SerializeField] private float attackCooldown = 1f;
    [SerializeField] private float damage = 10f;
    [SerializeField] private TargetingMode targetingMode = TargetingMode.First;
    [SerializeField] private GameObject projectilePrefab;
    [SerializeField] private Transform shootAnchor;
    
    private List<ITargetable> targetsInRange = new List<ITargetable>();
    
    // IAttacker implementation
    public Transform Transform => transform;
    public GameObject GameObject => gameObject;
    public float AttackRange => attackRange;
    public float AttackCooldown => attackCooldown;
    public float CurrentCooldown { get; set; }
    public bool CanAttack => CurrentCooldown <= 0f;
    public ITargetable CurrentTarget { get; set; }
    public TargetingMode TargetingMode => targetingMode;
    public float Damage => damage;
    public GameObject ProjectilePrefab => projectilePrefab;
    public Transform ShootAnchor => shootAnchor;
    
    public void PerformAttack(ITargetable target)
    {
        // Spawn projectile from pool
        GameObject projObj = PoolManager.Instance.Pull(projectilePrefab);
        projObj.transform.position = shootAnchor.position;
        
        // Configure projectile
        if (projObj.TryGetComponent<Projectile>(out var projectile))
        {
            Vector3 direction = (target.Position - shootAnchor.position).normalized;
            projectile.Launch(direction, 15f, damage);
        }
    }
    
    public void FocusOnTarget(Vector3 targetPosition)
    {
        // Rotate tower to face target
        Vector3 direction = targetPosition - transform.position;
        direction.y = 0;
        if (direction != Vector3.zero)
        {
            Quaternion targetRotation = Quaternion.LookRotation(direction);
            // Smooth rotation
        }
    }
    
    public void OnTargetAcquired(ITargetable target) { }
    public void OnTargetLost() { }
    public void OnAttackCompleted() { }
    
    // Registration
    private void Start()
    {
        AttackSystem.Instance?.RegisterAttacker(this);
        StartCoroutine(UpdateTargetsCoroutine());
    }
    
    private void OnDestroy()
    {
        AttackSystem.Instance?.UnregisterAttacker(this);
    }
    
    // Target scanning (coroutine - 5 times/sec instead of 50!)
    private IEnumerator UpdateTargetsCoroutine()
    {
        WaitForSeconds wait = new WaitForSeconds(0.2f);
        
        while (true)
        {
            yield return wait;
            
            // Scan for targets
            targetsInRange.Clear();
            Collider[] colliders = Physics.OverlapSphere(
                transform.position, 
                attackRange, 
                LayerMask.GetMask("Enemy")
            );
            
            foreach (var col in colliders)
            {
                if (col.TryGetComponent<ITargetable>(out var targetable))
                {
                    targetsInRange.Add(targetable);
                }
            }
            
            // Update AttackSystem cache
            AttackSystem.Instance?.UpdateTargetsInRange(this, targetsInRange);
        }
    }
}

5.3 ProjectileSystem

Purpose

Manages projectile lifecycle, movement, collision detection, and pooling.

Responsibilities

• Register/unregister IProjectile entities

• Update projectile positions

• Check collision with targets

• Handle projectile expiration (lifetime)

• Return projectiles to pool

Architecture

ProjectileSystem
├─ Priority: 2 (after attack)
├─ Entities: List<IProjectile>
└─ Tick(): foreach projectile → move → check hit → expire

Full Implementation

using System.Collections.Generic;
using UnityEngine;

public class ProjectileSystem : MonoBehaviour, IGameSystem
{
    // Singleton
    public static ProjectileSystem Instance { get; private set; }
    
    // System Properties
    public int Priority => 2; // After attack
    public bool IsActive { get; set; } = true;
    
    // Entity Registry
    private List<IProjectile> activeProjectiles = new List<IProjectile>();
    
    // Lifecycle
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
    }
    
    public void Initialize()
    {
        Debug.Log("[ProjectileSystem] Initialized");
    }
    
    public void Shutdown()
    {
        activeProjectiles.Clear();
        Debug.Log("[ProjectileSystem] Shutdown");
    }
    
    // Main Update Loop
    public void Tick(float deltaTime)
    {
        // BATCH PROCESSING - iterate backwards (safe removal)
        for (int i = activeProjectiles.Count - 1; i >= 0; i--)
        {
            IProjectile projectile = activeProjectiles[i];
            
            // 1. Update lifetime
            projectile.CurrentLifetime += deltaTime;
            if (projectile.CurrentLifetime >= projectile.MaxLifetime)
            {
                // Expired - return to pool
                PoolManager.Instance.Push(projectile.GameObject);
                activeProjectiles.RemoveAt(i);
                continue;
            }
            
            // 2. Update position
            projectile.UpdatePosition(deltaTime);
            
            // 3. Check collision
            if (projectile.CheckHit(out ITargetable target))
            {
                // Hit target
                projectile.OnHit(target);
                
                // Return to pool
                PoolManager.Instance.Push(projectile.GameObject);
                activeProjectiles.RemoveAt(i);
            }
        }
    }
    
    // Entity Management
    public void RegisterProjectile(IProjectile projectile)
    {
        if (projectile == null)
            return;
        
        if (!activeProjectiles.Contains(projectile))
        {
            activeProjectiles.Add(projectile);
        }
    }
    
    public void UnregisterProjectile(IProjectile projectile)
    {
        if (projectile == null)
            return;
        
        activeProjectiles.Remove(projectile);
    }
    
    // Debug Info
    public int GetProjectileCount() => activeProjectiles.Count;
    
    private void OnDestroy()
    {
        if (Instance == this)
        {
            Instance = null;
        }
    }
}

Performance Metrics

BEFORE (individual Update()):
20 projectiles × Update() = 1,200 calls/second

AFTER (batch processing):
1 ProjectileSystem.Tick() = 60 calls/second

Improvement: 95% reduction

Usage Example

public class Projectile : MonoBehaviour, IProjectile
{
    [SerializeField] private float speed = 15f;
    [SerializeField] private float maxLifetime = 5f;
    
    private Rigidbody rb;
    private Vector3 direction;
    private float damage;
    private float currentLifetime;
    
    private void Awake()
    {
        rb = GetComponent<Rigidbody>();
    }
    
    // ⚠️ CRITICAL: Use OnEnable for pooled objects!
    private void OnEnable()
    {
        // Reset state (runs every spawn from pool)
        currentLifetime = 0f;
        
        // Register with system
        ProjectileSystem.Instance?.RegisterProjectile(this);
    }
    
    private void OnDisable()
    {
        // Unregister from system
        ProjectileSystem.Instance?.UnregisterProjectile(this);
    }
    
    public void Launch(Vector3 launchDirection, float launchSpeed, float dmg)
    {
        direction = launchDirection.normalized;
        speed = launchSpeed;
        damage = dmg;
        
        // Set velocity
        rb.velocity = direction * speed;
    }
    
    // IProjectile implementation
    public GameObject GameObject => gameObject;
    public float CurrentLifetime 
    { 
        get => currentLifetime;
        set => currentLifetime = value;
    }
    public float MaxLifetime => maxLifetime;
    
    public void UpdatePosition(float deltaTime)
    {
        // Physics handles movement via Rigidbody
        // Override for homing projectiles
    }
    
    public bool CheckHit(out ITargetable target)
    {
        target = null;
        
        // Raycast ahead to check for hit
        RaycastHit hit;
        if (Physics.Raycast(
            transform.position, 
            direction, 
            out hit, 
            speed * Time.deltaTime,
            LayerMask.GetMask("Enemy")))
        {
            if (hit.collider.TryGetComponent<ITargetable>(out target))
            {
                return true;
            }
        }
        
        return false;
    }
    
    public void OnHit(ITargetable target)
    {
        // Deal damage
        if (target is IDamageable damageable)
        {
            damageable.TakeDamage(damage);
        }
        
        // Play hit effect
        // ...
    }
}

5.4 EffectSystem

Purpose

Centralized processor for status effects (burn, slow, poison, stun, etc.).

Responsibilities

• Register/unregister IEffect entities

• Update effect durations

• Process effect ticks (DOT damage, debuffs)

• Handle effect expiration

• Manage effect stacking/overrides

Architecture

EffectSystem
├─ Priority: 3 (after projectiles)
├─ Entities: List<IEffect>
└─ Tick(): foreach effect → duration → tick → expire

Full Implementation

using System.Collections.Generic;
using UnityEngine;

public class EffectSystem : MonoBehaviour, IGameSystem
{
    // Singleton
    public static EffectSystem Instance { get; private set; }
    
    // System Properties
    public int Priority => 3; // After projectiles
    public bool IsActive { get; set; } = true;
    
    // Entity Registry
    private List<IEffect> activeEffects = new List<IEffect>();
    
    // Lifecycle
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
    }
    
    public void Initialize()
    {
        Debug.Log("[EffectSystem] Initialized");
    }
    
    public void Shutdown()
    {
        activeEffects.Clear();
        Debug.Log("[EffectSystem] Shutdown");
    }
    
    // Main Update Loop
    public void Tick(float deltaTime)
    {
        // BATCH PROCESSING - iterate backwards (safe removal)
        for (int i = activeEffects.Count - 1; i >= 0; i--)
        {
            IEffect effect = activeEffects[i];
            
            // 1. Update duration (if not infinite)
            if (!effect.IsInfinite)
            {
                effect.CurrentDuration -= deltaTime;
                
                if (effect.CurrentDuration <= 0f)
                {
                    // Effect expired
                    effect.ExpireEffect();
                    activeEffects.RemoveAt(i);
                    continue;
                }
            }
            
            // 2. Update tick timer
            effect.CurrentTickTime -= deltaTime;
            
            // 3. Perform tick if ready
            if (effect.CurrentTickTime <= 0f)
            {
                effect.PerformTick();
                effect.CurrentTickTime = effect.TickInterval;
            }
        }
    }
    
    // Entity Management
    public void RegisterEffect(IEffect effect)
    {
        if (effect == null)
            return;
        
        if (!activeEffects.Contains(effect))
        {
            activeEffects.Add(effect);
            effect.OnEffectStarted();
            Debug.Log($"[EffectSystem] Registered: {effect.GetType().Name}");
        }
    }
    
    public void UnregisterEffect(IEffect effect)
    {
        if (effect == null)
            return;
        
        activeEffects.Remove(effect);
        effect.OnEffectEnded();
        Debug.Log($"[EffectSystem] Unregistered: {effect.GetType().Name}");
    }
    
    public void ApplyEffect(GameObject target, IEffect effect)
    {
        // Apply effect to target
        RegisterEffect(effect);
    }
    
    // Debug Info
    public int GetEffectCount() => activeEffects.Count;
    
    private void OnDestroy()
    {
        if (Instance == this)
        {
            Instance = null;
        }
    }
}

Performance Metrics

BEFORE (individual Update()):
30 StatusEffect × Update() = 1,800 calls/second
1,800 virtual method calls/second

AFTER (batch processing):
1 EffectSystem.Tick() = 60 calls/second
~300 PerformTick() calls/second (only when ready)

Improvement: 97% reduction

Usage Example

public class BurnEffect : StatusEffect, IEffect
{
    [SerializeField] private float damagePerTick = 5f;
    [SerializeField] private float tickInterval = 1f; // 1 second
    [SerializeField] private float duration = 5f;
    
    private GameObject affectedTarget;
    private float currentDuration;
    private float currentTickTime;
    
    // IEffect implementation
    public GameObject TargetGameObject => affectedTarget;
    public float CurrentDuration 
    { 
        get => currentDuration;
        set => currentDuration = value;
    }
    public float CurrentTickTime 
    { 
        get => currentTickTime;
        set => currentTickTime = value;
    }
    public float TickInterval => tickInterval;
    public bool IsInfinite => false;
    
    public void PerformTick()
    {
        // Apply DOT damage
        if (affectedTarget != null && 
            affectedTarget.TryGetComponent<IDamageable>(out var damageable))
        {
            damageable.TakeDamage(damagePerTick);
            
            // Visual feedback
            ShowBurnVFX();
        }
    }
    
    public void ExpireEffect()
    {
        OnEffectEnded();
        Destroy(gameObject);
    }
    
    public void OnEffectStarted()
    {
        // Initialize effect
        currentDuration = duration;
        currentTickTime = tickInterval;
        
        // Visual: Change target color to red
        if (affectedTarget != null &&
            affectedTarget.TryGetComponent<Renderer>(out var renderer))
        {
            renderer.material.color = Color.red;
        }
    }
    
    public void OnEffectEnded()
    {
        // Cleanup
        if (affectedTarget != null &&
            affectedTarget.TryGetComponent<Renderer>(out var renderer))
        {
            renderer.material.color = Color.white;
        }
    }
    
    public void Initialize(GameObject target, float effectDuration)
    {
        affectedTarget = target;
        duration = effectDuration;
        
        // Register with EffectSystem
        EffectSystem.Instance?.RegisterEffect(this);
    }
    
    public void DestroyEffect()
    {
        // Unregister from EffectSystem
        EffectSystem.Instance?.UnregisterEffect(this);
        
        Destroy(gameObject);
    }
    
    private void ShowBurnVFX()
    {
        // Spawn fire particles, play sound, etc.
    }
}

---

6. Entity Design

6.1 Entity Principles

Entities Are Data Providers

Key Concept: Entities hold state and implement interfaces, but contain NO Update() logic.

Anti-Pattern:

// ❌ BAD: Entity with Update() logic
public class Enemy : MonoBehaviour
{
    private void Update()
    {
        // Movement logic
        transform.position += direction * speed * Time.deltaTime;
        
        // Health check
        if (currentHealth <= 0)
            Die();
        
        // Effect processing
        ProcessStatusEffects();
    }
}

Correct Pattern:

// ✅ GOOD: Entity as data provider
public class Enemy : MonoBehaviour, IMoveable, IDamageable
{
    // STATE (data only)
    private float currentHealth = 100f;
    private float moveSpeed = 5f;
    private Vector3 direction;
    
    // NO Update() method!
    
    // Interface implementations provide data to systems
    public Transform Transform => transform;
    public float Speed => moveSpeed;
    public Vector3 Direction { get; set; }
    public bool IsMoving { get; set; } = true;
    
    public void UpdatePosition(float deltaTime)
    {
        // Logic invoked by MovementSystem, not Update()
        transform.position += Direction * Speed * deltaTime;
    }
    
    public float CurrentHealth => currentHealth;
    
    public void TakeDamage(float amount)
    {
        currentHealth -= amount;
        if (currentHealth <= 0)
            Die();
    }
    
    // LIFECYCLE: Registration only
    private void OnEnable()
    {
        MovementSystem.Instance?.RegisterMoveable(this);
    }
    
    private void OnDisable()
    {
        MovementSystem.Instance?.UnregisterMoveable(this);
    }
}

Registration Pattern

Always register in OnEnable, unregister in OnDisable:

public class Entity : MonoBehaviour, IMoveable
{
    // ✅ CORRECT
    private void OnEnable()
    {
        MovementSystem.Instance?.RegisterMoveable(this);
    }
    
    private void OnDisable()
    {
        MovementSystem.Instance?.UnregisterMoveable(this);
    }
    
    // ❌ WRONG
    private void Start()
    {
        MovementSystem.Instance?.RegisterMoveable(this);
    }
    
    private void OnDestroy()
    {
        // Too late! Object might already be destroyed
        MovementSystem.Instance?.UnregisterMoveable(this);
    }
}

Why OnEnable/OnDisable?

1. Works with object pooling: OnEnable runs every time object is pulled from pool Start runs only ONCE per GameObject lifetime

2. Symmetric lifecycle: OnEnable ↔ OnDisable are pairs Awake ↔ OnDestroy are pairs

3. Proper cleanup: OnDisable guaranteed to run before destruction OnDestroy might be too late

6.2 Enemy Entity

Complete Implementation

using UnityEngine;

/// <summary>
/// Base class for all enemy types.
/// Implements movement, damage, and targeting capabilities.
/// </summary>
public class Enemy : MonoBehaviour, IMoveable, IDamageable, ITargetable, IPoolable
{
    [Header("Movement")]
    [SerializeField] protected float moveSpeed = 5f;
    
    [Header("Combat")]
    [SerializeField] protected float maxHealth = 100f;
    
    [Header("Rewards")]
    [SerializeField] protected int goldReward = 10;
    
    // State
    protected float currentHealth;
    protected Vector3 direction;
    protected bool isMoving = true;
    protected int waypointIndex;
    
    // Initialization
    protected virtual void Awake()
    {
        currentHealth = maxHealth;
    }
    
    // Registration
    protected virtual void OnEnable()
    {
        MovementSystem.Instance?.RegisterMoveable(this);
        
        // Reset state (for pooling)
        currentHealth = maxHealth;
        isMoving = true;
    }
    
    protected virtual void OnDisable()
    {
        MovementSystem.Instance?.UnregisterMoveable(this);
    }
    
    // IMoveable Implementation
    public Transform Transform => transform;
    public float Speed => moveSpeed;
    public Vector3 Direction 
    { 
        get => direction;
        set => direction = value;
    }
    public bool IsMoving 
    { 
        get => isMoving;
        set => isMoving = value;
    }
    
    public void UpdatePosition(float deltaTime)
    {
        if (!isMoving)
            return;
        
        // Move along path
        transform.position += direction * moveSpeed * deltaTime;
    }
    
    // IDamageable Implementation
    public float MaxHealth => maxHealth;
    public float CurrentHealth => currentHealth;
    
    public void TakeDamage(float amount)
    {
        currentHealth -= amount;
        
        // Visual feedback
        OnDamageTaken(amount);
        
        if (currentHealth <= 0)
        {
            Die();
        }
    }
    
    public void Heal(float amount)
    {
        currentHealth = Mathf.Min(currentHealth + amount, maxHealth);
    }
    
    // ITargetable Implementation
    public Vector3 Position => transform.position;
    public bool IsAlive => currentHealth > 0;
    public int WaypointIndex 
    { 
        get => waypointIndex;
        set => waypointIndex = value;
    }
    
    // IPoolable Implementation
    public GameObject GameObject => gameObject;
    public bool IsInPool { get; set; }
    
    public void OnSpawnedFromPool()
    {
        currentHealth = maxHealth;
        isMoving = true;
    }
    
    public void OnReturnedToPool()
    {
        isMoving = false;
    }
    
    // Death
    protected virtual void Die()
    {
        // Award gold
        GameState.Instance?.AddGold(goldReward);
        
        // Emit event
        OnDied?.Invoke(this);
        
        // Visual/audio
        PlayDeathEffects();
        
        // Return to pool
        PoolManager.Instance.Push(gameObject);
    }
    
    // Events
    public event System.Action<Enemy> OnDied;
    
    // Virtual methods for subclasses
    protected virtual void OnDamageTaken(float amount)
    {
        // Override for custom damage feedback
    }
    
    protected virtual void PlayDeathEffects()
    {
        // Override for custom death VFX/SFX
    }
}

Enemy Variants

// Fast enemy: High speed, low HP
public class FastEnemy : Enemy
{
    protected override void Awake()
    {
        base.Awake();
        
        moveSpeed = 10f;  // 2× faster
        maxHealth = 50f;  // Half HP
        goldReward = 5;   // Less reward
    }
}

// Tank enemy: Slow, high HP
public class TankEnemy : Enemy
{
    protected override void Awake()
    {
        base.Awake();
        
        moveSpeed = 2f;   // Slow
        maxHealth = 300f; // Tanky
        goldReward = 50;  // High reward
    }
    
    protected override void PlayDeathEffects()
    {
        base.PlayDeathEffects();
        
        // Tank explosion
        // Spawn particles, screen shake, etc.
    }
}

// Healer enemy: Heals nearby enemies
public class HealerEnemy : Enemy
{
    [SerializeField] private float healAmount = 10f;
    [SerializeField] private float healInterval = 2f;
    [SerializeField] private float healRadius = 5f;
    
    private float healTimer;
    
    protected override void Awake()
    {
        base.Awake();
        
        moveSpeed = 4f;
        maxHealth = 80f;
    }
    
    // Note: Could create HealerSystem for this logic!
    // For now, using coroutine
    private void OnEnable()
    {
        base.OnEnable();
        StartCoroutine(HealCoroutine());
    }
    
    private IEnumerator HealCoroutine()
    {
        WaitForSeconds wait = new WaitForSeconds(healInterval);
        
        while (true)
        {
            yield return wait;
            
            // Find nearby enemies
            Collider[] colliders = Physics.OverlapSphere(
                transform.position, 
                healRadius,
                LayerMask.GetMask("Enemy")
            );
            
            foreach (var col in colliders)
            {
                if (col.gameObject != gameObject && // Not self
                    col.TryGetComponent<IDamageable>(out var damageable))
                {
                    damageable.Heal(healAmount);
                }
            }
        }
    }
}

6.3 Tower Entity

Complete Implementation

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Base class for all tower types.
/// Implements attack capability via AttackSystem.
/// </summary>
public class Tower : MonoBehaviour, IAttacker
{
    [Header("Attack")]
    [SerializeField] protected float attackRange = 5f;
    [SerializeField] protected float attackCooldown = 1f;
    [SerializeField] protected float damage = 10f;
    
    [Header("Targeting")]
    [SerializeField] protected TargetingMode targetingMode = TargetingMode.First;
    
    [Header("Projectile")]
    [SerializeField] protected GameObject projectilePrefab;
    [SerializeField] protected Transform shootAnchor;
    [SerializeField] protected float projectileSpeed = 15f;
    
    [Header("Rotation")]
    [SerializeField] protected Transform rotationPart;
    [SerializeField] protected float rotationSpeed = 5f;
    
    // State
    protected List<ITargetable> targetsInRange = new List<ITargetable>();
    protected float currentCooldown;
    protected ITargetable currentTarget;
    
    // Registration
    protected virtual void Start()
    {
        // Register with AttackSystem
        AttackSystem.Instance?.RegisterAttacker(this);
        
        // Start target scanning coroutine
        StartCoroutine(UpdateTargetsCoroutine());
    }
    
    protected virtual void OnDestroy()
    {
        AttackSystem.Instance?.UnregisterAttacker(this);
    }
    
    // Target Scanning (coroutine - 5 scans/sec instead of 50!)
    protected virtual IEnumerator UpdateTargetsCoroutine()
    {
        WaitForSeconds wait = new WaitForSeconds(0.2f); // 5 times/sec
        
        while (true)
        {
            yield return wait;
            
            // Scan for targets in range
            targetsInRange.Clear();
            Collider[] colliders = Physics.OverlapSphere(
                transform.position,
                attackRange,
                LayerMask.GetMask("Enemy")
            );
            
            foreach (var col in colliders)
            {
                if (col.TryGetComponent<ITargetable>(out var targetable))
                {
                    targetsInRange.Add(targetable);
                }
            }
            
            // Update AttackSystem cache
            AttackSystem.Instance?.UpdateTargetsInRange(this, targetsInRange);
        }
    }
    
    // IAttacker Implementation
    public Transform Transform => transform;
    public GameObject GameObject => gameObject;
    public float AttackRange => attackRange;
    public float AttackCooldown => attackCooldown;
    public float CurrentCooldown 
    { 
        get => currentCooldown;
        set => currentCooldown = value;
    }
    public bool CanAttack => currentCooldown <= 0f;
    public ITargetable CurrentTarget 
    { 
        get => currentTarget;
        set => currentTarget = value;
    }
    public TargetingMode TargetingMode => targetingMode;
    public float Damage => damage;
    public GameObject ProjectilePrefab => projectilePrefab;
    public Transform ShootAnchor => shootAnchor;
    
    public virtual void PerformAttack(ITargetable target)
    {
        // Spawn projectile from pool
        GameObject projObj = PoolManager.Instance.Pull(projectilePrefab);
        projObj.transform.position = shootAnchor.position;
        projObj.transform.rotation = shootAnchor.rotation;
        
        // Configure projectile
        if (projObj.TryGetComponent<Projectile>(out var projectile))
        {
            Vector3 direction = (target.Position - shootAnchor.position).normalized;
            projectile.Launch(direction, projectileSpeed, damage);
        }
        
        // Play attack effects
        PlayAttackEffects();
    }
    
    public void FocusOnTarget(Vector3 targetPosition)
    {
        if (rotationPart == null)
            return;
        
        // Rotate tower to face target
        Vector3 direction = targetPosition - transform.position;
        direction.y = 0; // Keep horizontal
        
        if (direction != Vector3.zero)
        {
            Quaternion targetRotation = Quaternion.LookRotation(direction);
            rotationPart.rotation = Quaternion.Slerp(
                rotationPart.rotation,
                targetRotation,
                rotationSpeed * Time.deltaTime
            );
        }
    }
    
    public virtual void OnTargetAcquired(ITargetable target)
    {
        // Override for custom behavior
    }
    
    public virtual void OnTargetLost()
    {
        // Override for custom behavior
    }
    
    public virtual void OnAttackCompleted()
    {
        // Override for custom behavior
    }
    
    // Virtual methods for subclasses
    protected virtual void PlayAttackEffects()
    {
        // Override for custom attack VFX/SFX
    }
}

Tower Variants

// Basic Tower: Standard damage, medium range
public class BasicTower : Tower
{
    // Uses base implementation
}

// Sniper Tower: High damage, long range, slow fire rate
public class SniperTower : Tower
{
    protected override void Start()
    {
        base.Start();
        
        attackRange = 15f;   // Long range
        attackCooldown = 3f; // Slow fire rate
        damage = 50f;        // High damage
    }
}

// Splash Tower: AOE damage
public class SplashTower : Tower
{
    [SerializeField] private float splashRadius = 3f;
    [SerializeField] private float splashDamagePercent = 0.5f;
    
    public override void PerformAttack(ITargetable target)
    {
        base.PerformAttack(target); // Spawn projectile
        
        // Apply splash damage to nearby enemies
        Collider[] nearbyEnemies = Physics.OverlapSphere(
            target.Position,
            splashRadius,
            LayerMask.GetMask("Enemy")
        );
        
        foreach (var col in nearbyEnemies)
        {
            if (col.TryGetComponent<IDamageable>(out var damageable))
            {
                if (col.gameObject != target.GameObject)
                {
                    damageable.TakeDamage(damage * splashDamagePercent);
                }
            }
        }
    }
}

// Slow Tower: Applies slow effect
public class SlowTower : Tower
{
    [SerializeField] private GameObject slowEffectPrefab;
    [SerializeField] private float slowDuration = 3f;
    
    public override void OnAttackCompleted()
    {
        base.OnAttackCompleted();
        
        if (CurrentTarget != null)
        {
            // Apply slow effect
            GameObject effectObj = Instantiate(slowEffectPrefab);
            var slowEffect = effectObj.GetComponent<SlowEffect>();
            slowEffect.Initialize(CurrentTarget.GameObject, slowDuration);
        }
    }
}

---

7. Performance Principles

7.1 Batch Processing

Core Concept

Replace N individual operations with 1 batch operation:

Individual Processing:
foreach (entity) { entity.Update() } ← N function calls

Batch Processing:
System.Tick() { foreach (entity) { ProcessEntity(entity) } } ← 1 function call

Why It's Faster

Reason 1: Reduced Function Call Overhead

// Individual (slow):
// Unity calls Update() on 100 entities
// = 100× MonoBehaviour→Update dispatch
// = 100× virtual method lookup
// = ~1ms overhead

// Batch (fast):
// Unity calls Update() on 1 system
// System calls ProcessEntity() on 100 entities
// = 1× MonoBehaviour→Update dispatch
// = 100× direct method calls (no virtual lookup)
// = ~0.01ms overhead

Reason 2: Cache-Friendly Memory Access

Individual Update():
Entity #1 at address 0x1000
Entity #47 at address 0x5000  ← Cache miss!
Entity #3 at address 0x1100
Entity #82 at address 0x9000  ← Cache miss!
Random jumps = poor cache utilization

Batch Processing:
List<Entity> stored contiguously:
Entity #0 at address 0x2000
Entity #1 at address 0x2020  ← Cache hit!
Entity #2 at address 0x2040  ← Cache hit!
Entity #3 at address 0x2060  ← Cache hit!
Sequential access = excellent cache utilization

Reason 3: Compiler Optimizations

// Batch loop can be optimized by compiler:
for (int i = 0; i < entities.Length; i++)
{
    entities[i].Process(deltaTime);
}

// Compiler can:
// - Unroll loop
// - Vectorize operations (SIMD)
// - Prefetch next entities
// = Additional 2-4× speedup

Performance Impact

Test: 100 entities moving

Individual Update():
100 × Update() calls = 0.5ms/frame
Poor cache = +0.3ms
Virtual dispatch = +0.2ms
TOTAL: ~1ms/frame

Batch Processing:
1 × Tick() call = 0.01ms
Good cache = no penalty
Direct calls = no penalty
Compiler optimizations = -50%
TOTAL: ~0.05ms/frame

Speedup: 20×

7.2 Cache Optimization

CPU Cache Hierarchy

┌─────────────────────────────────────────────┐
│  L1 Cache:  32 KB,  4 cycles   (fastest)   │
│  L2 Cache:  256 KB, 12 cycles               │
│  L3 Cache:  8 MB,   40 cycles               │
│  RAM:       16 GB,  200 cycles  (slowest)   │
└─────────────────────────────────────────────┘

Goal: Keep data in L1/L2 cache as much as possible.

Sequential vs Random Access

// ❌ BAD: Random access (cache misses)
public class Enemy : MonoBehaviour
{
    void Update()
    {
        // Each entity scattered in memory
        // CPU must fetch from RAM every time
        transform.position += direction * speed * Time.deltaTime;
    }
}

// ✅ GOOD: Sequential access (cache hits)
public class MovementSystem : MonoBehaviour
{
    private List<IMoveable> moveables; // Contiguous array
    
    void Tick(float deltaTime)
    {
        // Iterate sequentially
        for (int i = 0; i < moveables.Count; i++)
        {
            // CPU prefetches next entity while processing current
            moveables[i].UpdatePosition(deltaTime);
        }
    }
}

Data Locality

Principle: Keep related data together.

// ❌ BAD: Scattered data
public class Enemy : MonoBehaviour
{
    public float health;      // Address: 0x1000
    public Vector3 position;  // Address: 0x1020
    public Vector3 velocity;  // Address: 0x1040
}
// Each field might be on different cache line!

// ✅ GOOD: Tightly packed data
public struct EnemyData
{
    public float health;      // Address: 0x2000
    public Vector3 position;  // Address: 0x2004
    public Vector3 velocity;  // Address: 0x2010
}
// All fields fit in single cache line (64 bytes)!

Array of Structures (AoS) vs Structure of Arrays (SoA)

// AoS (less cache-friendly):
public struct Enemy
{
    public Vector3 position;
    public Vector3 velocity;
    public float health;
}
Enemy[] enemies = new Enemy[100];

// When updating positions, CPU loads entire Enemy struct
// (position + velocity + health) even if only using position!

// SoA (more cache-friendly):
public class EnemyData
{
    public Vector3[] positions = new Vector3[100];
    public Vector3[] velocities = new Vector3[100];
    public float[] healths = new float[100];
}

// When updating positions, CPU loads ONLY positions array
// = Better cache utilization!

Performance Impact:

Test: Update 1000 enemy positions

AoS: Load 1000 × Enemy struct (48 bytes each) = 48 KB
     = Exceeds L1 cache (32 KB)
     = Many cache misses
     = ~0.5ms/frame

SoA: Load 1000 × Vector3 (12 bytes each) = 12 KB
     = Fits in L1 cache
     = Minimal cache misses
     = ~0.1ms/frame

Speedup: 5×

7.3 Avoiding LINQ in Hot Paths

Why LINQ Is Slow

Reason 1: Memory Allocations

var target = targets
    .OrderBy(t => t.WaypointIndex)  // Allocates iterator
    .FirstOrDefault();               // Allocates delegate

// EVERY call allocates ~200 bytes of garbage
// 500 calls/sec × 200 bytes = 100 KB/sec garbage
// GC collects every 5 seconds = 100ms spike!

Reason 2: Virtual Calls & Delegates

// OrderBy creates delegate:
Func<Target, int> keySelector = t => t.WaypointIndex;

// EVERY comparison calls delegate:
// = Virtual call overhead
// = No inlining possible
// = 10-20× slower than direct comparison

Reason 3: Unnecessary Work

// OrderBy sorts ENTIRE array:
targets.OrderBy(t => t.WaypointIndex) // O(n log n)

// But we only need MAX:
// = Can be done in O(n)!

Manual Iteration Instead

// ❌ SLOW (LINQ):
var target = targets
    .OrderByDescending(t => t.WaypointIndex)
    .FirstOrDefault();

// ✅ FAST (Manual):
ITargetable best = null;
int maxIndex = int.MinValue;

for (int i = 0; i < targets.Count; i++)
{
    int index = targets[i].WaypointIndex;
    if (index > maxIndex)
    {
        best = targets[i];
        maxIndex = index;
    }
}

return best;

Performance Comparison:

Test: Find enemy with highest waypoint index (10 enemies)

LINQ (OrderBy + FirstOrDefault):
- Time: ~0.05ms
- Allocations: ~200 bytes
- GC pressure: High

Manual Iteration:
- Time: ~0.002ms
- Allocations: 0 bytes
- GC pressure: Zero

Speedup: 25×
Allocation reduction: 100%

When LINQ Is Acceptable

Outside hot paths:

// ✅ OK: Setup phase (called once)
void Start()
{
    allTowers = FindObjectsOfType<Tower>()
        .OrderBy(t => t.name)
        .ToList();
}

// ❌ NOT OK: Hot path (called every frame)
void Update()
{
    var target = targets.OrderBy(t => t.hp).FirstOrDefault();
}

Rule of Thumb:

• LINQ in initialization/setup: ✅ OK

• LINQ in Update/Tick/FixedUpdate: ❌ NEVER

• LINQ called <1 time/second: ✅ Probably OK

• LINQ called >10 times/second: ❌ Replace with manual

7.4 Coroutines for Infrequent Tasks

Problem: FixedUpdate for Non-Physics Tasks

// ❌ BAD: FixedUpdate for target scanning
void FixedUpdate() // Called 50 times/second
{
    // Scan for targets
    Collider[] colliders = Physics.OverlapSphere(...);
    // Heavy operation 50 times/sec!
}

Issues:

• FixedUpdate is for physics (rigidbody integration)

• Target scanning doesn't need physics precision

• Enemies don't move fast enough to require 50 scans/sec

• Waste of CPU

Solution: Coroutine with Delay

// ✅ GOOD: Coroutine for target scanning
IEnumerator UpdateTargetsCoroutine()
{
    WaitForSeconds wait = new WaitForSeconds(0.2f); // 5 times/sec
    
    while (true)
    {
        yield return wait;
        
        // Scan for targets
        Collider[] colliders = Physics.OverlapSphere(...);
        // Only 5 times/sec instead of 50!
    }
}

Benefits:

• 90% reduction in calls (50 → 5 per second)

• No noticeable gameplay difference (targets update fast enough)

• Simple to implement

Performance Impact

Test: 10 towers scanning for targets

FixedUpdate:
10 towers × 50 calls/sec = 500 calls/sec
500 × Physics.OverlapSphere = ~3ms/frame

Coroutine (0.2s interval):
10 towers × 5 calls/sec = 50 calls/sec
50 × Physics.OverlapSphere = ~0.3ms/frame

Speedup: 10×

When to Use Coroutines

Good for:

• Target scanning (5-10 times/sec sufficient)

• Pathfinding requests (1-5 times/sec)

• AI decision making (1-2 times/sec)

• UI updates (not every frame)

Bad for:

• Movement (needs every frame)

• Combat resolution (must be immediate)

• Physics interactions (use FixedUpdate)

• Input handling (must be responsive)

Rule of Thumb:

• If task needs to run every frame: Use system Tick()

• If task can run 1-10 times/sec: Use coroutine

• If task runs once: Use direct call

---

8. Best Practices

8.1 System Design Guidelines

1. Single Responsibility Principle

Each system handles ONE concern:

// ✅ GOOD: Focused responsibility
public class MovementSystem : IGameSystem
{
    // ONLY handles movement
    public void Tick(float deltaTime)
    {
        foreach (var moveable in moveables)
        {
            moveable.UpdatePosition(deltaTime);
        }
    }
}

// ❌ BAD: Mixed responsibilities
public class MovementSystem : IGameSystem
{
    public void Tick(float deltaTime)
    {
        foreach (var moveable in moveables)
        {
            moveable.UpdatePosition(deltaTime); // Movement
            CheckCollisions(moveable);          // Physics (wrong system!)
            UpdateAnimation(moveable);          // Animation (wrong system!)
        }
    }
}

2. Clear Priority Order

Define explicit execution order:

// ✅ GOOD: Explicit priorities
MovementSystem.Priority    = 0; // Move first
AttackSystem.Priority      = 1; // Attack after movement
ProjectileSystem.Priority  = 2; // Projectiles after attack
EffectSystem.Priority      = 3; // Effects last

// ❌ BAD: Implicit order (undefined behavior)
// Systems execute in arbitrary order
// = Race conditions!

3. Batch Processing Always

Process ALL entities in single pass:

// ✅ GOOD: Single pass
public void Tick(float deltaTime)
{
    for (int i = 0; i < entities.Count; i++)
    {
        entities[i].Process(deltaTime);
    }
}

// ❌ BAD: Multiple passes
public void Tick(float deltaTime)
{
    // First pass
    foreach (var entity in entities)
    {
        entity.PrepareUpdate();
    }
    
    // Second pass (unnecessary!)
    foreach (var entity in entities)
    {
        entity.Update(deltaTime);
    }
}

4. Interface-Based Design

Work with interfaces, not concrete classes:

// ✅ GOOD: Interface-based
public class MovementSystem : IGameSystem
{
    private List<IMoveable> moveables; // Interface
    
    public void RegisterMoveable(IMoveable moveable)
    {
        moveables.Add(moveable);
    }
}

// ❌ BAD: Concrete class dependency
public class MovementSystem : IGameSystem
{
    private List<Enemy> enemies; // Concrete class
    
    public void RegisterEnemy(Enemy enemy)
    {
        enemies.Add(enemy);
    }
}
// Can only handle Enemy, not other IMoveable types!

8.2 Entity Design Guidelines

1. No Update() in Entities

Entities provide data, systems provide logic:

// ✅ GOOD: Data provider
public class Enemy : MonoBehaviour, IMoveable
{
    public Transform Transform => transform;
    public float Speed => moveSpeed;
    
    public void UpdatePosition(float deltaTime)
    {
        // Called by MovementSystem, not Update()
        transform.position += direction * Speed * deltaTime;
    }
    
    // NO Update() method!
}

// ❌ BAD: Self-updating entity
public class Enemy : MonoBehaviour
{
    void Update()
    {
        // Logic in entity instead of system
        transform.position += direction * speed * Time.deltaTime;
    }
}

2. OnEnable/OnDisable Registration

Always use OnEnable/OnDisable, not Start/OnDestroy:

// ✅ GOOD: OnEnable/OnDisable
void OnEnable()
{
    MovementSystem.Instance?.RegisterMoveable(this);
}

void OnDisable()
{
    MovementSystem.Instance?.UnregisterMoveable(this);
}

// ❌ BAD: Start/OnDestroy
void Start()
{
    // Doesn't work with object pooling!
    MovementSystem.Instance?.RegisterMoveable(this);
}

void OnDestroy()
{
    // Might be too late (object already destroyed)
    MovementSystem.Instance?.UnregisterMoveable(this);
}

3. Interface Composition

Implement multiple interfaces for multiple capabilities:

// ✅ GOOD: Composition
public class Enemy : MonoBehaviour, IMoveable, IDamageable, ITargetable
{
    // Implements all interfaces
}

// ❌ BAD: Single capability
public class Enemy : MonoBehaviour, IMoveable
{
    // Only moveable, but also needs damage & targeting
    // = Must add methods manually without interface contract
}

4. Minimal Public API

Expose only what systems need:

// ✅ GOOD: Minimal API
public class Enemy : MonoBehaviour, IMoveable
{
    private float moveSpeed = 5f; // Private
    
    public float Speed => moveSpeed; // Public (needed by interface)
}

// ❌ BAD: Everything public
public class Enemy : MonoBehaviour
{
    public float moveSpeed = 5f;     // Public (unnecessary)
    public Vector3 direction;        // Public (unnecessary)
    public float currentHealth;      // Public (unnecessary)
}
// Encourages tight coupling!

8.3 Performance Guidelines

1. Profile Before Optimizing

Always measure:

1. Establish baseline (record FPS, frame time)
2. Identify bottleneck (Unity Profiler)
3. Make targeted fix
4. Measure again (verify improvement)
5. Repeat

Don't optimize blindly!

2. Avoid Premature Optimization

// ❌ BAD: Premature optimization
// Spending time on micro-optimizations that don't matter

// Before profiling:
public void Process()
{
    // Trying to optimize this:
    float value = Mathf.Sqrt(x * x + y * y);
    // But this method is called once per second!
    // = Waste of time
}

// ✅ GOOD: Profile-driven optimization
// Unity Profiler shows MovementSystem.Tick() takes 5ms
// = That's the real bottleneck!

3. Cache Component References

// ❌ BAD: GetComponent every frame
void Update()
{
    GetComponent<Rigidbody>().velocity = direction * speed;
}

// ✅ GOOD: Cache in Awake
private Rigidbody rb;

void Awake()
{
    rb = GetComponent<Rigidbody>();
}

void Update()
{
    rb.velocity = direction * speed;
}

4. Use Object Pooling

// ❌ BAD: Instantiate/Destroy
void SpawnProjectile()
{
    GameObject proj = Instantiate(projectilePrefab);
}

void OnProjectileHit()
{
    Destroy(gameObject);
}

// ✅ GOOD: Object pooling
void SpawnProjectile()
{
    GameObject proj = PoolManager.Instance.Pull(projectilePrefab);
}

void OnProjectileHit()
{
    PoolManager.Instance.Push(gameObject);
}

5. Avoid Allocations in Hot Paths

// ❌ BAD: Allocations every frame
void Update()
{
    List<Enemy> temp = new List<Enemy>(); // Allocation!
    foreach (var enemy in enemies)
    {
        if (enemy.IsAlive)
            temp.Add(enemy);
    }
}

// ✅ GOOD: Reuse list
private List<Enemy> aliveEnemies = new List<Enemy>();

void Update()
{
    aliveEnemies.Clear(); // Reuse
    foreach (var enemy in enemies)
    {
        if (enemy.IsAlive)
            aliveEnemies.Add(enemy);
    }
}

8.4 Testing Guidelines

1. Unit Test Systems in Isolation

[Test]
public void MovementSystem_UpdatesEntityPosition()
{
    // Arrange
    MovementSystem system = CreateMovementSystem();
    MockMoveable entity = new MockMoveable
    {
        Position = Vector3.zero,
        Direction = Vector3.forward,
        Speed = 5f
    };
    system.RegisterMoveable(entity);
    
    // Act
    system.Tick(1f); // 1 second
    
    // Assert
    Assert.AreEqual(new Vector3(0, 0, 5), entity.Position);
}

2. Integration Test System Interactions

[UnityTest]
public IEnumerator AttackSystem_DamagesTarget()
{
    // Arrange
    GameSystemsManager manager = CreateGameSystemsManager();
    Tower tower = CreateTower();
    Enemy enemy = CreateEnemy();
    
    // Wait for systems to initialize
    yield return null;
    
    // Act
    yield return new WaitForSeconds(tower.AttackCooldown + 0.1f);
    
    // Assert
    Assert.Less(enemy.CurrentHealth, enemy.MaxHealth);
}

3. Performance Test with Profiler

[UnityTest, Performance]
public IEnumerator MovementSystem_Performance_100Entities()
{
    // Arrange
    MovementSystem system = CreateMovementSystem();
    for (int i = 0; i < 100; i++)
    {
        system.RegisterMoveable(CreateMockMoveable());
    }
    
    // Measure
    using (Measure.Frames().SampleGroup("MovementSystem.Tick"))
    {
        system.Tick(Time.deltaTime);
    }
    
    yield return null;
    
    // Assert: Should process 100 entities in <1ms
}

---

9. Migration Guide

9.1 From Monolithic to System-Based

Step 1: Identify Systems

Analyze your codebase:

Current Update() methods:
- Enemy.Update() → Movement logic
- Tower.Update() → Attack logic
- StatusEffect.Update() → Effect logic
- Projectile.Update() → Movement logic

Systems needed:
- MovementSystem (Enemy, Projectile)
- AttackSystem (Tower)
- EffectSystem (StatusEffect)

Step 2: Create Interfaces

Define capability contracts:

// Movement capability
public interface IMoveable
{
    Transform Transform { get; }
    float Speed { get; }
    Vector3 Direction { get; set; }
    bool IsMoving { get; set; }
    void UpdatePosition(float deltaTime);
}

// Attack capability
public interface IAttacker
{
    Transform Transform { get; }
    float AttackRange { get; }
    float AttackCooldown { get; }
    float CurrentCooldown { get; set; }
    ITargetable CurrentTarget { get; set; }
    void PerformAttack(ITargetable target);
}

// Continue for all capabilities...

Step 3: Implement Systems

Create system classes:

public class MovementSystem : MonoBehaviour, IGameSystem
{
    public int Priority => 0;
    public bool IsActive { get; set; } = true;
    
    private List<IMoveable> moveables = new List<IMoveable>();
    
    public void Initialize() { }
    
    public void Tick(float deltaTime)
    {
        foreach (var moveable in moveables)
        {
            if (moveable.IsMoving)
                moveable.UpdatePosition(deltaTime);
        }
    }
    
    public void Shutdown()
    {
        moveables.Clear();
    }
    
    public void RegisterMoveable(IMoveable moveable)
    {
        moveables.Add(moveable);
    }
    
    public void UnregisterMoveable(IMoveable moveable)
    {
        moveables.Remove(moveable);
    }
}

Step 4: Refactor Entities

Remove Update(), implement interfaces:

// BEFORE:
public class Enemy : MonoBehaviour
{
    void Update()
    {
        transform.position += direction * speed * Time.deltaTime;
    }
}

// AFTER:
public class Enemy : MonoBehaviour, IMoveable
{
    // NO Update()!
    
    public Transform Transform => transform;
    public float Speed => moveSpeed;
    public Vector3 Direction { get; set; }
    public bool IsMoving { get; set; } = true;
    
    public void UpdatePosition(float deltaTime)
    {
        transform.position += Direction * Speed * deltaTime;
    }
    
    void OnEnable()
    {
        MovementSystem.Instance?.RegisterMoveable(this);
    }
    
    void OnDisable()
    {
        MovementSystem.Instance?.UnregisterMoveable(this);
    }
}

Step 5: Create GameSystemsManager

Orchestrate all systems:

public class GameSystemsManager : MonoBehaviour
{
    private List<IGameSystem> systems = new List<IGameSystem>();
    
    void Awake()
    {
        // Create and register systems
        RegisterSystem(CreateSystem<MovementSystem>(0));
        RegisterSystem(CreateSystem<AttackSystem>(1));
        RegisterSystem(CreateSystem<EffectSystem>(2));
        
        // Initialize
        foreach (var system in systems)
        {
            system.Initialize();
        }
    }
    
    void Update()
    {
        float deltaTime = Time.deltaTime;
        
        foreach (var system in systems)
        {
            if (system.IsActive)
                system.Tick(deltaTime);
        }
    }
}

Step 6: Test & Validate

Verify functionality:

1. ✅ Game runs without errors

2. ✅ All entities move correctly

3. ✅ Combat works as before

4. ✅ Effects apply correctly

5. ✅ Performance improved (measure FPS)

9.2 Common Migration Pitfalls

Pitfall 1: Forgetting Unregistration

// ❌ WRONG: Memory leak
void OnEnable()
{
    MovementSystem.Instance?.RegisterMoveable(this);
}

// OnDisable missing!
// Entity still registered after destruction!

// ✅ CORRECT:
void OnDisable()
{
    MovementSystem.Instance?.UnregisterMoveable(this);
}

Pitfall 2: Using Start Instead of OnEnable

// ❌ WRONG: Doesn't work with object pooling
void Start()
{
    MovementSystem.Instance?.RegisterMoveable(this);
}
// Start only runs ONCE per GameObject!

// ✅ CORRECT:
void OnEnable()
{
    MovementSystem.Instance?.RegisterMoveable(this);
}
// OnEnable runs every time object activated!

Pitfall 3: Wrong System Priority

// ❌ WRONG: Attack before movement
MovementSystem.Priority = 1;
AttackSystem.Priority = 0;

// Towers select targets based on OLD positions!
// = Wrong targets selected

// ✅ CORRECT:
MovementSystem.Priority = 0; // Move first
AttackSystem.Priority = 1;   // Attack after
// Towers see updated positions!

Pitfall 4: Keeping Update() Methods

// ❌ WRONG: Both Update() and system
public class Enemy : MonoBehaviour, IMoveable
{
    void Update()
    {
        // Still here! Defeats purpose of systems!
        transform.position += direction * speed * Time.deltaTime;
    }
    
    public void UpdatePosition(float deltaTime)
    {
        // Also here!
    }
}

// ✅ CORRECT: Only system method
public class Enemy : MonoBehaviour, IMoveable
{
    // NO Update()!
    
    public void UpdatePosition(float deltaTime)
    {
        transform.position += Direction * Speed * deltaTime;
    }
}

---

10. Appendix

10.1 Glossary

Batch Processing: Processing multiple entities in single loop instead of individual Update() calls.

Cache Locality: Keeping frequently accessed data close together in memory for faster access.

ECS (Entity Component System): Architecture pattern separating data (Entity/Component) from logic (System).

Hot Path: Code that executes frequently (every frame). Must be highly optimized.

Interface: Contract defining capabilities an entity must provide.

Pooling: Reusing GameObjects instead of destroying/instantiating to reduce overhead.

System: Centralized logic processor that batch processes entities.

Tick(): Main update method for systems (replaces Update()).

10.2 Performance Benchmarks

Test Environment

• Hardware: RTX 4060, Intel i7-12700, 32GB RAM

• Unity Version: 2022.3.12f1

• Build: Release (not Editor)

• VSync: Disabled

• Quality: Medium

Results

Metric	Before Refactor	After Refactor	Improvement
FPS (Wave 7)	63.9	144.1	+125%
CPU Time	15.6ms	6.9ms	-56%
Update() Calls	11,900/sec	50/sec	-99.5%
Batches	7,277	1,917	-74%
Shadow Casters	9,125	83	-99%
GC Allocations	150 KB/sec	5 KB/sec	-97%

Load Testing

Scenario	Before	After
50 enemies	80 FPS	144 FPS
100 enemies	45 FPS	120 FPS
200 enemies	20 FPS (unplayable)	80 FPS

10.3 References

Unity Documentation

• Unity Profiler

• Frame Debugger

• SRP Batcher

• Object Pooling

Design Patterns

• Game Programming Patterns - Robert Nystrom

• SOLID Principles

• Entity Component System

Performance Optimization

• CPU Cache and Why You Care

• Data-Oriented Design

• Unity Performance Best Practices

---

📝 Document Revision History

Version	Date	Changes
1.0	December 2024	Initial release
2.0	December 2025	Complete rewrite with Markdown format, expanded examples, performance benchmarks

---

This Architecture Handbook is a living document. Contributions and feedback welcome.

Maintainer: Senior Unity Developer Last Review: December 2025 Next Review: June 2026