DontDestroyOnLoad usage in Unity - Step-by-Step Execution

Concept Flow - DontDestroyOnLoad usage

Start Scene

↓

Create GameObject

↓

Call DontDestroyOnLoad

↓

Load New Scene

↓

GameObject persists

↓

Continue Game with same GameObject

This flow shows how a GameObject is created, marked to not be destroyed, and then persists across scene loads.

Execution Sample

Unity

void Awake() {
  DontDestroyOnLoad(gameObject);
}

// Load new scene later

This code marks the GameObject to persist when a new scene loads.

Execution Table

Step	Action	GameObject State	Scene Loaded	Result
1	GameObject created in Scene 1	Exists in Scene 1	Scene 1	GameObject active
2	DontDestroyOnLoad called on GameObject	Marked to persist	Scene 1	GameObject will not be destroyed on scene load
3	Load Scene 2	Still exists	Scene 2	GameObject persists across scenes
4	Game continues in Scene 2	Exists in Scene 2	Scene 2	GameObject usable in new scene
5	Load Scene 3	Still exists	Scene 3	GameObject persists again
6	End	GameObject still alive	Scene 3	Execution stops

💡 Execution stops after GameObject persists through scene loads

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
gameObject	Created in Scene 1	Marked DontDestroyOnLoad	Exists in Scene 2	Exists in Scene 3	Still exists

Key Moments - 3 Insights

Why doesn't the GameObject get destroyed when a new scene loads?

Because DontDestroyOnLoad was called on the GameObject (see Step 2 in execution_table), it is marked to persist and Unity keeps it alive across scene loads.

Does DontDestroyOnLoad prevent the GameObject from being destroyed manually?

No, DontDestroyOnLoad only prevents destruction during scene loads. The GameObject can still be destroyed by code or user actions.

What happens if you call DontDestroyOnLoad on multiple GameObjects?

Each marked GameObject will persist across scenes independently, allowing you to keep multiple objects alive (not shown in this trace but same principle applies).

Visual Quiz - 3 Questions

Look at the execution_table, at which step is DontDestroyOnLoad called on the GameObject?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Check the 'Action' column in execution_table for when DontDestroyOnLoad is called

According to variable_tracker, what is the state of the GameObject after loading Scene 3?

A Exists in Scene 3

B Marked DontDestroyOnLoad but destroyed

C Destroyed

D Not created yet

💡 Hint

Look at the 'After Step 5' column for gameObject in variable_tracker

If DontDestroyOnLoad was not called, what would happen at Step 3 when loading Scene 2?

A GameObject would persist

B Scene would not load

C GameObject would be destroyed

D GameObject would duplicate

💡 Hint

Recall that without DontDestroyOnLoad, GameObjects in the old scene are destroyed on scene load

Concept Snapshot

DontDestroyOnLoad usage in Unity:
- Call DontDestroyOnLoad(gameObject) in Awake or Start
- Marks GameObject to persist across scene loads
- Prevents destruction only during scene changes
- Useful for managers, audio, or player objects
- GameObject remains active and usable in new scenes

Full Transcript

This visual execution trace shows how DontDestroyOnLoad works in Unity. First, a GameObject is created in the starting scene. Then, DontDestroyOnLoad is called on it, marking it to persist. When a new scene loads, normally all objects are destroyed, but this GameObject stays alive. It continues to exist and be usable in the new scene. The variable tracker confirms the GameObject's state after each step. Key points include that DontDestroyOnLoad only prevents destruction during scene loads, not manual destruction. The quiz questions help reinforce understanding of when and why the GameObject persists.

Practice

1. What is the main purpose of using DontDestroyOnLoad in Unity?

easy

A. To pause the game during scene loading

B. To destroy a GameObject immediately

C. To load a new scene asynchronously

D. To keep a GameObject alive when switching scenes

Solution

1. Step 1: Understand what DontDestroyOnLoad does

   This method prevents a GameObject from being destroyed when a new scene loads.

2. Step 2: Identify the purpose in scene management

   It keeps important objects like music players or managers alive across scenes.

3. Final Answer:

   To keep a GameObject alive when switching scenes -> Option D

4. Quick Check:

   DontDestroyOnLoad keeps objects alive = A [OK]

Hint: Remember: DontDestroyOnLoad means object stays between scenes [OK]

Common Mistakes:

• Thinking it destroys objects instead of preserving them
• Confusing it with scene loading functions
• Assuming it pauses the game

2. Which of the following is the correct way to use DontDestroyOnLoad in a Unity script?

easy

A. DontDestroyOnLoad(this);

B. DontDestroyOnLoad(Scene);

C. DontDestroyOnLoad(gameObject);

D. DontDestroyOnLoad(SceneManager);

Solution

1. Step 1: Identify the correct parameter for DontDestroyOnLoad

   The method requires a GameObject to keep alive, usually referenced as gameObject in scripts.

2. Step 2: Check each option

   DontDestroyOnLoad(gameObject); uses gameObject, which is correct. DontDestroyOnLoad(this); uses this (the script), which is incorrect. Options B and C use unrelated types.

3. Final Answer:

   DontDestroyOnLoad(gameObject); -> Option C

4. Quick Check:

   Use gameObject with DontDestroyOnLoad = D [OK]

Hint: Use gameObject, not this or Scene, with DontDestroyOnLoad [OK]

Common Mistakes:

• Passing 'this' instead of 'gameObject'
• Trying to pass Scene or SceneManager objects
• Calling DontDestroyOnLoad without parameters

3. Consider this Unity C# script attached to a GameObject:

void Awake() {
    DontDestroyOnLoad(gameObject);
}

void Start() {
    Debug.Log("Object alive");
}

What will happen when the scene changes?

medium

A. The GameObject will persist and "Object alive" will print once

B. The GameObject will be destroyed and "Object alive" will not print again

C. The GameObject will persist and "Object alive" will print every scene load

D. The GameObject will be duplicated on each scene load

Solution

1. Step 1: Understand when Awake and Start run

   Awake runs once when the object is created. Start runs once after Awake. Both run only once per object lifetime.

2. Step 2: Effect of DontDestroyOnLoad on scene change

   The GameObject is kept alive across scenes, so Awake and Start do not run again on scene load.

3. Final Answer:

   The GameObject will persist and "Object alive" will print once -> Option A

4. Quick Check:

   DontDestroyOnLoad keeps object alive, Awake/Start run once = A [OK]

Hint: Awake/Start run once; object stays alive with DontDestroyOnLoad [OK]

Common Mistakes:

• Thinking Start runs on every scene load
• Assuming object duplicates on scene change
• Believing object is destroyed on scene change

4. You wrote this code in a Unity script:

void Start() {
    DontDestroyOnLoad(this);
}

What is the problem and how to fix it?

medium

A. Error: DontDestroyOnLoad must be called in Awake, not Start

B. Error: 'this' is not a GameObject; fix by using DontDestroyOnLoad(gameObject);

C. No problem; code works fine as is

D. Error: DontDestroyOnLoad requires a Scene parameter

Solution

1. Step 1: Identify the parameter type for DontDestroyOnLoad

   DontDestroyOnLoad requires a GameObject, but 'this' refers to the script instance, not the GameObject.

2. Step 2: Correct the parameter

   Use gameObject to pass the GameObject the script is attached to.

3. Final Answer:

   Error: 'this' is not a GameObject; fix by using DontDestroyOnLoad(gameObject); -> Option B

4. Quick Check:

   DontDestroyOnLoad needs gameObject, not this = C [OK]

Hint: Pass gameObject, not this, to DontDestroyOnLoad [OK]

Common Mistakes:

• Passing 'this' instead of 'gameObject'
• Thinking DontDestroyOnLoad must be in Awake only
• Passing wrong types like Scene or SceneManager

5. You want to keep a music player GameObject alive across scenes but avoid duplicates if the scene reloads. Which code snippet correctly implements this using DontDestroyOnLoad?

hard

A. void Awake() {
if (FindObjectsOfType<MusicPlayer>().Length > 1) {
Destroy(gameObject);
} else {
DontDestroyOnLoad(gameObject);
}
}

B. void Awake() {
DontDestroyOnLoad(gameObject);
}

C. void Start() {
Destroy(gameObject);
DontDestroyOnLoad(gameObject);
}

D. void Awake() {
Destroy(gameObject);
}

Solution

1. Step 1: Understand the problem of duplicates

   Using DontDestroyOnLoad alone keeps the object alive, but reloading the scene creates duplicates.

2. Step 2: Use a check to destroy duplicates

   void Awake() { if (FindObjectsOfType<MusicPlayer>().Length > 1) { Destroy(gameObject); } else { DontDestroyOnLoad(gameObject); } } checks if more than one MusicPlayer exists and destroys the extra one, preventing duplicates.

3. Step 3: Verify other options

   void Awake() { DontDestroyOnLoad(gameObject); } keeps duplicates. void Start() { Destroy(gameObject); DontDestroyOnLoad(gameObject); } destroys then calls DontDestroyOnLoad (wrong order). void Awake() { Destroy(gameObject); } destroys always.

4. Final Answer:

   void Awake() { if (FindObjectsOfType<MusicPlayer>().Length > 1) { Destroy(gameObject); } else { DontDestroyOnLoad(gameObject); } } -> Option A

5. Quick Check:

   Check duplicates before DontDestroyOnLoad to avoid duplicates = B [OK]

Hint: Check existing objects before DontDestroyOnLoad to prevent duplicates [OK]

Common Mistakes:

• Not checking for duplicates causing multiple music players
• Destroying object before calling DontDestroyOnLoad
• Calling DontDestroyOnLoad without duplicate check