DontDestroyOnLoad usage in Unity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to prevent the GameObject from being destroyed when loading a new scene.

Unity

void Awake() {
    [1](gameObject);
}

Drag options to blanks, or click blank then click option'

ADestroy

BDontDestroyOnLoad

CLoadScene

DInstantiate

Attempts:

3 left

💡 Hint

Common Mistakes

Using Destroy instead of DontDestroyOnLoad

Calling LoadScene inside Awake

Forgetting to pass the GameObject as parameter

The DontDestroyOnLoad method keeps the GameObject alive across scene loads.

2fill in blank

medium

Complete the code to ensure only one instance of the GameObject persists using DontDestroyOnLoad.

Unity

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

Drag options to blanks, or click blank then click option'

AGameManager

BTransform

CRigidbody

DCamera

Attempts:

3 left

💡 Hint

Common Mistakes

Using a Unity component like Transform instead of the script class

Not checking the length of found objects

Not calling Destroy on duplicates

This code checks if more than one GameManager exists and destroys duplicates, keeping only one persistent instance.

3fill in blank

hard

Fix the error in the code that tries to use DontDestroyOnLoad incorrectly.

Unity

void Start() {
    [1];
}

Drag options to blanks, or click blank then click option'

ADontDestroyOnLoad

BDestroy

CDontDestroyOnLoad(gameObject)

DDontDestroyOnLoad(this.gameObject)

Attempts:

3 left

💡 Hint

Common Mistakes

Passing 'this' instead of 'this.gameObject'

Calling DontDestroyOnLoad without parameters

Using Destroy instead of DontDestroyOnLoad

The DontDestroyOnLoad method requires a GameObject as parameter, so this.gameObject is correct.

4fill in blank

hard

Fill both blanks to create a singleton pattern that uses DontDestroyOnLoad correctly.

Unity

public class GameManager : MonoBehaviour {
    private static GameManager [1];

    void Awake() {
        if ([2] != null && [2] != this) {
            Destroy(gameObject);
            return;
        }
        [2] = this;
        DontDestroyOnLoad(gameObject);
    }
}

Drag options to blanks, or click blank then click option'

Ainstance

BgameObject

Cthis

Dmanager

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names for check and assignment

Using 'gameObject' instead of the static instance variable

Not making the variable static

The static variable instance holds the singleton reference. The code checks if instance exists and assigns this to it if not.

5fill in blank

hard

Fill all three blanks to complete the code that prevents multiple instances and uses DontDestroyOnLoad.

Unity

public class AudioManager : MonoBehaviour {
    private static AudioManager [1];

    void Awake() {
        if ([2] != null && [2] != this) {
            [3](gameObject);
            return;
        }
        [2] = this;
        DontDestroyOnLoad(gameObject);
    }
}

Drag options to blanks, or click blank then click option'

Ainstance

CDestroy

DDontDestroyOnLoad

Attempts:

3 left

💡 Hint

Common Mistakes

Using DontDestroyOnLoad instead of Destroy to remove duplicates

Using different variable names for the static instance

Not making the variable static

The static variable instance is used to track the singleton. Duplicate objects are destroyed using Destroy(gameObject).

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