Performance Optimization for Games

# CHAPTER 17

Performance Optimization for Games #

1. Introduction #

2. Learning Objectives #

• Identify CPU bottlenecks in your game logic.

• Understand C# Garbage Collection (GC) and how to avoid triggering it.

• Implement the Object Pooling design pattern for projectiles.

• Optimize continuous calculations in the Update loop.

• Use square magnitude math to bypass expensive distance calculations.

3. The Garbage Collector (The Framerate Killer) #

• If you create and destroy objects constantly, the GC runs constantly, causing massive micro-stuttering (FPS drops).

• The Goal: Generate as little "garbage" as possible during active gameplay.

4. The Solution: Object Pooling #

1. 1. When the level loads, spawn 50 bullets.

1. 2. Hide them all (SetActive(false)).

1. 3. When the player shoots, grab a hidden bullet, move it to the gun, and turn it on.

1. 4. When it hits a wall, *don't destroy it*. Just hide it again!

5. Optimizing the Update Loop #

• Never use Find() in Update: GameObject.Find("Player") forces the CPU to scan the entire level comparing text strings. It is incredibly slow. Find the player *once* in Start(), save the reference to a variable, and use the variable in Update().

• Avoid GetComponent() in Update: Same rule. Cache your components in Start().

// BAD - Lags the game!
void Update()
{
    GameObject.Find("Player").GetComponent<Health>().TakeDamage(1);
}

// GOOD - Lightning fast!
Health playerHealth;

void Start()
{
    // Cache it once!
    playerHealth = GameObject.Find("Player").GetComponent<Health>();
}

void Update()
{
    playerHealth.TakeDamage(1);
}

6. Math Optimization (sqrMagnitude) #

• However, Distance requires the CPU to calculate a Square Root, which is a very complex math operation.

• Instead, use sqrMagnitude (the distance *squared*) and compare it to the distance you want, also squared!

// Expensive (Requires Square Root calculation)
if (Vector3.Distance(enemy.pos, player.pos) < 5.0f) { ... }

// Cheap & Fast (No Square Root required!)
if ((enemy.pos - player.pos).sqrMagnitude < (5.0f * 5.0f)) { ... }

7. Visual Learning: Object Pooling #

[ BULLET POOL (List of 5 Bullets) ]
1. [HIDDEN]  2. [HIDDEN]  3. [HIDDEN]  4. [HIDDEN]  5. [HIDDEN]

*Player Shoots!* -> Grab Bullet 1, Move to Gun, Make VISIBLE.
1. [ACTIVE]  2. [HIDDEN]  3. [HIDDEN]  4. [HIDDEN]  5. [HIDDEN]

*Bullet Hits Wall!* -> Move to Pool, Make HIDDEN. (NO DESTROY CALLED)
1. [HIDDEN]  2. [HIDDEN]  3. [HIDDEN]  4. [HIDDEN]  5. [HIDDEN]

8. Best Practices #

• Use Timers for Non-Critical Logic: Does an enemy really need to search for the player 60 times a second? No. Use a Coroutine or a Timer variable to run the detection logic only 4 times a second (every 0.25s). The player won't notice the difference, and you just saved 93% of the CPU cost for that script!

9. Common Mistakes #

• String Concatenation in Update: Writing scoreText.text = "Score: " + currentScore; inside Update() generates a brand new string in RAM every single frame. Strings are immutable in C#. This generates massive garbage. Only update UI strings *exactly when the score changes*.

10. Mini Project: Build a Simple Object Pool #

using System.Collections.Generic;

class BulletPool
{
    public GameObject bulletPrefab;
    private List<GameObject> pool = new List<GameObject>();

    void Start()
    {
        // 1. Pre-warm the pool with 20 hidden bullets
        for (int i = 0; i < 20; i++)
        {
            GameObject obj = Instantiate(bulletPrefab);
            obj.SetActive(false); // Hide it
            pool.Add(obj);
        }
    }

    // 2. Dispense a bullet when requested
    public GameObject GetBullet()
    {
        foreach (GameObject bullet in pool)
        {
            if (!bullet.activeInHierarchy) // If it's hidden, it's available!
            {
                bullet.SetActive(true); // Turn it on
                return bullet;
            }
        }
        return null; // Pool is empty! (In reality, you would expand the pool here)
    }
}

11. Practice Exercises #

1. 1. Why is calling GameObject.Find() inside the Update() loop considered a severe performance flaw?

1. 2. What is the fundamental goal of the Object Pooling design pattern?

12. MCQs with Answers #

13. Interview Questions #

• Q: Explain the concept of Garbage Collection in C#. How does rapid memory allocation and deallocation lead to framerate micro-stuttering in a game engine?

• Q: Walk me through the architecture of an Object Pool. Why is toggling an object's active state significantly faster than instantiating and destroying it?

• Q: A junior developer writes an Enemy AI script that uses GameObject.FindWithTag("Player") inside the Update() method. Explain the CPU cost of this action and how you would refactor it using caching in the Start() method.

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #