This assessment evaluates your understanding of Unity's component-based architecture, how GameObjects and their components interact, the hierarchy system with nested GameObjects, and how to reference them in scripts.

You’re using GameObject.Find("Player") in Awake() , but the player is instantiated later in the scene.

The “Player” GameObject is disabled at the time you call GetComponent<PlayerHealth>().

You neither assigned the playerHealth variable in the Inspector nor used FindObjectOfType<PlayerHealth>() in the script.

Imagine you’re creating a “Dark Souls” styled action RPG in Unity. 

You have a Player game object with a `PlayerHealth` component.

You have a `GameManager` script that needs to reference the `PlayerHealth` component on your Player.

But you notice occasional `NullReferenceExceptions` when trying to access `PlayerHealth`.

Which of the following could be legitimate reasons you are getting `NullReferenceExceptions` in this scenario?

Call FindObjectsOfType<Enemy>() in Update() for real-time detection.

Keep a static list in the Enemy class that registers/unregisters each Enemy in OnEnable()/OnDisable(), and have the radar read from that list.

Use GameObject.FindGameObjectsWithTag("Enemy") and tag all enemies accordingly, calling it whenever needed.

Store a reference to the first Enemy found and assume all enemies can be accessed via GetComponentInChildren<Enemy>() on that reference.

You’re creating a “Call of Duty” or “CS:GO” - style shooter in Unity. 

You want a minimap or radar system that periodically shows all active enemies on the map. You initially code it like this:

`Enemy[] allEnemies = FindObjectsOfType<Enemy>();`

However, enemies spawn dynamically during the game, and your radar system only checks once at the start.

What is the best potential fix to ensure your radar system consistently tracks newly spawned enemies?

The restart spawns new Racer objects, and the old references in the UI script are now pointing to destroyed objects.

Unity automatically clears all script references when any GameObject in the scene is renamed, so the race restart triggers a rename event that resets those references.

The UI script is on a different layer than the racers, causing all cross-layer references to default to null after the scene reloads.

References to script components cannot persist for more than 60 seconds of gameplay unless they’re periodically refreshed in Update().

In a “Mario Kart” - style racer, you have a UI script that displays each racer’s position. 

It references the `RacerController` for Player 1 and Player 2 via the Inspector. After a race restarts, the UI script’s references to both racers become `null`.

Which of the following scenarios best explains why these references might become `null`?

For tasks that never change or move, you can simply drag each TaskStation into the TaskManager Inspector fields on a game controller object.

Use FindObjectsOfType<TaskStation>() in Start(), once per scene, if tasks are finite and pre-placed.

Dynamically spawned tasks should register themselves to the TaskManager in OnEnable().

If multiple scenes contain tasks, always rely on FindWithTag("Task") each time you switch scenes to ensure references are fresh.

You’re recreating a simplified **Among Us** system in Unity. 

Each “Task” station has a `TaskStation` script. Crewmates have a `TaskManager` component listing all tasks they need to complete.

Which statement is *the best practice* for referencing all `TaskStation` in the scene?

When HealthBarController exists only on a child object and not on the same GameObject as UIController.

When the child object is inactive, and you need to find it anyway.

When you want to find multiple HealthBarController components across various child objects in the “HUD.”

When you’re looking for any HealthBarController in the entire scene, not just the children of the “HUD.”

You’re creating a “**League of Legends**” style game where your HUD has many nested child objects for different bars and counters (health, mana, special meters, etc.).

You have a `UIController` script on the top-level “HUD” object, and a nested “Health Bar” child with a `HealthBarController` script. When you do:

`var healthBarController = GetComponent<HealthBarController>();`

from within `UIController`, it returns `null`.

In which situation would `GetComponentInChildren<HealthBarController>()` be a better fit than `GetComponent<HealthBarController>()` here?

The script name includes the word “Sword,” which Unity doesn’t allow for GetComponent to detect.

The GreatSword script is on a child GameObject rather than the same GameObject where GetComponent<MeleeWeapon>() is called.

GreatSword is marked as an abstract class and can’t be instantiated (thus GreatSword script might not actually exist on that object).

The script execution order for GreatSword is after MeleeWeapon, causing the component to be null until everything is fully loaded.

You’re making a “Monster Hunter” like game, where you have a base `Weapon` class. 

You have a `MeleeWeapon` subclass, and a final subclass called `GreatSword`. 

You have a  “Weapon” game object that has a `GreatSword` script attached.

In your “Weapon” Game Object, you write:  

`MeleeWeapon weapon = GetComponent<MeleeWeapon>();` 

But it returns `null` during runtime.

Which reasons might explain why `GetComponent<MeleeWeapon>()` doesn’t return the `GreatSword` component?

Add every PuzzleTrigger reference to the PuzzleManager in the Inspector, assuming they never change.

Use a static list in each PuzzleTrigger that registers in OnEnable() and unregisters in OnDisable(), so PuzzleManager can read the updated list anytime.

Call FindObjectsOfType<PuzzleTrigger>()  in Update() to discover new triggers as soon as they spawn.

Place PuzzleManager on the same GameObject as one trigger and rely on GetComponent<PuzzleTrigger>() to manage them all.

You’re implementing a Zelda-style dungeon puzzle. 

A puzzle room has multiple triggers (pressure plates), each with a `PuzzleTrigger` script. 

The central `PuzzleManager` must detect when all triggers are active to open the door.

How will you search for references of these `PuzzleTrigger` scripts in `PuzzleManager?`

Store AbilityManager in a static variable so it can be accessed from any script without needing a reference.

Use GetComponent<AbilityManager> in Start() on the same GameObject that holds both the hero script and AbilityManager.

Continuously call FindObjectsOfType<AbilityManager>() every frame to ensure the reference updates in real-time.

Pass a new AbilityManager instance to every hero script in the scene using a custom constructor.

You’re building a hero-based shooter like Overwatch. 

Each hero has an `AbilityManager` responsible for various abilities (Dash, Shield, Heal, etc.).

Sometimes, during gameplay, the hero’s script can’t find its `AbilityManager` reference and throws `NullReferenceException` errors.

Which single solution is most likely to resolve these null reference errors in a typical setup?

Event-Driven Registration: Each new Buildable calls BuildManager.Register(this) in its OnEnable() method.

Frequent Scene Searches: Call FindObjectsOfType<Buildable>() every few frames to rebuild the list of all existing build pieces.

Singleton Access: Make BuildManager a singleton and let each Buildable itself do BuildManager.Instance.Register(this) upon spawn.

Manual Assignment: Pause the game in the Inspector and manually link each new build piece to the BuildManager reference field.

You’re working on a Fortnite-like building feature. 

Players can place walls, ramps, and floors at runtime. Each build piece (like a Wall) has a `Buildable` component. 

Your `BuildManager` needs to keep track of these build pieces to, for example, manage health or limit how many can be built.

Which strategies could effectively help the `BuildManager` track all newly spawned buildables without excessive performance overhead?

The collision is happening on an NPC’s child object, which doesn’t have the DialogueController. Because the manager only checks the object that triggered the collision, it can’t find the DialogueController on the child, and the dialogue never starts.

There are multiple cameras in the scene, so Unity cannot reliably find the correct DialogueController.

Dialogue is only possible if the NPC’s name matches a specific string, such as “TalkToMeNPC,” which some NPCs don’t have.

DialogueManager is set to DontDestroyOnLoad() while NPCs are not, so the manager forcibly deletes any DialogueController that doesn’t persist across scene loads.

You’re designing a Skyrim-like NPC dialogue system. 

As the player approaches an NPC, your `DialogueManager` must locate the NPC’s `DialogueController` to start a conversation. During playtesting, some NPCs fail to trigger dialogue, indicating that the `DialogueController` reference might be missing.

Which is the most plausible explanation for why certain NPCs do not trigger dialogue?

Unity Component Communication